/root/firefox-clang/intl/icu/source/common/cmemory.h

Bug Summary

File:	root/firefox-clang/intl/icu/source/common/cmemory.h
Warning:	line 274, column 40 Returning null reference

Annotated Source Code

Press '?' to see keyboard shortcuts

Show analyzer invocation

clang -cc1 -cc1 -triple x86_64-pc-linux-gnu -O2 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name locid.cpp -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model pic -pic-level 2 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -ffp-contract=off -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fdebug-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/config/external/icu/common -fcoverage-compilation-dir=/root/firefox-clang/obj-x86_64-pc-linux-gnu/config/external/icu/common -resource-dir /usr/lib/llvm-23/lib/clang/23 -include /root/firefox-clang/config/gcc_hidden.h -include /root/firefox-clang/obj-x86_64-pc-linux-gnu/mozilla-config.h -D _GLIBCXX_ASSERTIONS=1 -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/system_wrappers -U _FORTIFY_SOURCE -D _FORTIFY_SOURCE=2 -D DEBUG=1 -D U_COMMON_IMPLEMENTATION -D _LIBCPP_DISABLE_DEPRECATION_WARNINGS -D U_USING_ICU_NAMESPACE=0 -D U_NO_DEFAULT_INCLUDE_UTF_HEADERS=1 -D U_HIDE_OBSOLETE_UTF_OLD_H=1 -D UCONFIG_NO_LEGACY_CONVERSION -D UCONFIG_NO_TRANSLITERATION -D UCONFIG_NO_REGULAR_EXPRESSIONS -D UCONFIG_NO_BREAK_ITERATION -D UCONFIG_NO_IDNA -D UCONFIG_NO_MF2 -D UCONFIG_NO_NORMALIZATION -D UCONFIG_NO_COLLATION -D U_CHARSET_IS_UTF8 -D UNISTR_FROM_CHAR_EXPLICIT=explicit -D UNISTR_FROM_STRING_EXPLICIT=explicit -D U_ENABLE_DYLOAD=0 -D U_DEBUG=1 -I /root/firefox-clang/config/external/icu/common -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/config/external/icu/common -I /root/firefox-clang/intl/icu/source/i18n -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nspr -I /root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/nss -D MOZILLA_CLIENT -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../include/c++/16 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../include/x86_64-linux-gnu/c++/16 -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../include/c++/16/backward -internal-isystem /usr/lib/llvm-23/lib/clang/23/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-linux-gnu/16/../../../../x86_64-linux-gnu/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -Wno-error=pessimizing-move -Wno-error=large-by-value-copy=128 -Wno-error=implicit-int-float-conversion -Wno-error=thread-safety-analysis -Wno-error=tautological-type-limit-compare -Wno-invalid-offsetof -Wno-range-loop-analysis -Wno-deprecated-anon-enum-enum-conversion -Wno-deprecated-enum-enum-conversion -Wno-inline-new-delete -Wno-error=deprecated-declarations -Wno-error=array-bounds -Wno-error=free-nonheap-object -Wno-error=atomic-alignment -Wno-error=deprecated-builtins -Wno-psabi -Wno-error=builtin-macro-redefined -Wno-vla-cxx-extension -Wno-unknown-warning-option -Wno-character-conversion -Wno-comma -Wno-implicit-const-int-float-conversion -Wno-macro-redefined -Wno-microsoft-include -Wno-tautological-unsigned-enum-zero-compare -Wno-unreachable-code-loop-increment -Wno-unreachable-code-return -std=gnu++20 -fdeprecated-macro -ferror-limit 19 -fstrict-flex-arrays=1 -stack-protector 2 -fstack-clash-protection -ftrivial-auto-var-init=pattern -fgnuc-version=4.2.1 -fno-implicit-modules -fskip-odr-check-in-gmf -fno-sized-deallocation -fno-aligned-allocation -fdiagnostics-absolute-paths -vectorize-loops -vectorize-slp -analyzer-checker optin.performance.Padding -analyzer-output=html -analyzer-config stable-report-filename=true -mllvm -dwarf-linkage-names=Abstract -faddrsig -fdwarf2-cfi-asm -o /tmp/scan-build-2026-09-01-224014-2642839-1 -x c++ /root/firefox-clang/intl/icu/source/common/locid.cpp

/root/firefox-clang/intl/icu/source/common/locid.cpp

→

1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
**********************************************************************
*   Copyright (C) 1997-2016, International Business Machines
*   Corporation and others.  All Rights Reserved.
**********************************************************************
8*
9* File locid.cpp
10*
11* Created by: Richard Gillam
12*
13* Modification History:
14*
15*   Date        Name        Description
16*   02/11/97    aliu        Changed gLocPath to fgDataDirectory and added
17*                           methods to get and set it.
18*   04/02/97    aliu        Made operator!= inline; fixed return value
19*                           of getName().
20*   04/15/97    aliu        Cleanup for AIX/Win32.
21*   04/24/97    aliu        Numerous changes per code review.
22*   08/18/98    stephen     Changed getDisplayName()
23*                           Added SIMPLIFIED_CHINESE, TRADITIONAL_CHINESE
24*                           Added getISOCountries(), getISOLanguages(),
25*                           getLanguagesForCountry()
26*   03/16/99    bertrand    rehaul.
27*   07/21/99    stephen     Added U_CFUNC setDefault
28*   11/09/99    weiv        Added const char * getName() const;
29*   04/12/00    srl         removing unicodestring api's and cached hash code
30*   08/10/01    grhoten     Change the static Locales to accessor functions
31******************************************************************************
32*/

34#include <cstddef>
35#include <optional>
36#include <string_view>
37#include <type_traits>
38#include <utility>

40#include "unicode/bytestream.h"
41#include "unicode/locid.h"
42#include "unicode/localebuilder.h"
43#include "unicode/localpointer.h"
44#include "unicode/strenum.h"
45#include "unicode/stringpiece.h"
46#include "unicode/uloc.h"
47#include "unicode/ures.h"

49#include "bytesinkutil.h"
50#include "charstr.h"
51#include "charstrmap.h"
52#include "cmemory.h"
53#include "cstring.h"
54#include "fixedstring.h"
55#include "mutex.h"
56#include "putilimp.h"
57#include "uassert.h"
58#include "ucln_cmn.h"
59#include "uhash.h"
60#include "ulocimp.h"
61#include "umutex.h"
62#include "uniquecharstr.h"
63#include "ustr_imp.h"
64#include "uvector.h"

66U_NAMESPACE_BEGINnamespace icu_78 {

68static Locale   *gLocaleCache = nullptr;
69static UInitOnce gLocaleCacheInitOnce {};

71// gDefaultLocaleMutex protects all access to gDefaultLocalesHashT and gDefaultLocale.
72static UMutex gDefaultLocaleMutex;
73static UHashtable *gDefaultLocalesHashT = nullptr;
74static Locale *gDefaultLocale = nullptr;

76/**
* \def ULOC_STRING_LIMIT
* strings beyond this value crash in CharString
*/
80#define ULOC_STRING_LIMIT357913941 357913941

82U_NAMESPACE_END}

84typedef enum ELocalePos {
  eENGLISH,
  eFRENCH,
  eGERMAN,
  eITALIAN,
  eJAPANESE,
  eKOREAN,
  eCHINESE,

  eFRANCE,
  eGERMANY,
  eITALY,
  eJAPAN,
  eKOREA,
  eCHINA,      /* Alias for PRC */
  eTAIWAN,
  eUK,
  eUS,
  eCANADA,
  eCANADA_FRENCH,
  eROOT,


  //eDEFAULT,
  eMAX_LOCALES
109} ELocalePos;

111namespace {

113//
114// Deleter function for Locales owned by the default Locale hash table/
115//
116void U_CALLCONV
117deleteLocale(void *obj) {
  delete static_cast<icu::Locale*>(obj);
119}

121UBool U_CALLCONV locale_cleanup()
122{
  U_NAMESPACE_USEusing namespace icu_78;

  delete [] gLocaleCache;
  gLocaleCache = nullptr;
  gLocaleCacheInitOnce.reset();

  if (gDefaultLocalesHashT) {
      uhash_close(gDefaultLocalesHashT);   // Automatically deletes all elements, using deleter func.
      gDefaultLocalesHashT = nullptr;
  }
  gDefaultLocale = nullptr;
  return true;
135}

137void U_CALLCONV locale_init(UErrorCode &status) {
  U_NAMESPACE_USEusing namespace icu_78;

  U_ASSERT(gLocaleCache == nullptr)(static_cast <bool> (gLocaleCache == nullptr) ? void (0
) : __assert_fail ("gLocaleCache == nullptr", __builtin_FILE (
), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
  gLocaleCache = new Locale[static_cast<int>(eMAX_LOCALES)];
  if (gLocaleCache == nullptr) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return;
  }
  ucln_common_registerCleanup(UCLN_COMMON_LOCALE, locale_cleanup);
  gLocaleCache[eROOT]          = Locale("");
  gLocaleCache[eENGLISH]       = Locale("en");
  gLocaleCache[eFRENCH]        = Locale("fr");
  gLocaleCache[eGERMAN]        = Locale("de");
  gLocaleCache[eITALIAN]       = Locale("it");
  gLocaleCache[eJAPANESE]      = Locale("ja");
  gLocaleCache[eKOREAN]        = Locale("ko");
  gLocaleCache[eCHINESE]       = Locale("zh");
  gLocaleCache[eFRANCE]        = Locale("fr", "FR");
  gLocaleCache[eGERMANY]       = Locale("de", "DE");
  gLocaleCache[eITALY]         = Locale("it", "IT");
  gLocaleCache[eJAPAN]         = Locale("ja", "JP");
  gLocaleCache[eKOREA]         = Locale("ko", "KR");
  gLocaleCache[eCHINA]         = Locale("zh", "CN");
  gLocaleCache[eTAIWAN]        = Locale("zh", "TW");
  gLocaleCache[eUK]            = Locale("en", "GB");
  gLocaleCache[eUS]            = Locale("en", "US");
  gLocaleCache[eCANADA]        = Locale("en", "CA");
  gLocaleCache[eCANADA_FRENCH] = Locale("fr", "CA");
166}

168}  // namespace

170U_NAMESPACE_BEGINnamespace icu_78 {

172Locale *locale_set_default_internal(const char *id, UErrorCode& status) {
  // Synchronize this entire function.
  Mutex lock(&gDefaultLocaleMutex);

  UBool canonicalize = false;

  // If given a nullptr string for the locale id, grab the default
  //   name from the system.
  //   (Different from most other locale APIs, where a null name means use
  //    the current ICU default locale.)
  if (id == nullptr) {
      id = uprv_getDefaultLocaleID();   // This function not thread safe? TODO: verify.
      canonicalize = true; // always canonicalize host ID
  }

  CharString localeNameBuf =
      canonicalize ? ulocimp_canonicalize(id, status) : ulocimp_getName(id, status);

  if (U_FAILURE(status)) {
      return gDefaultLocale;
  }

  if (gDefaultLocalesHashT == nullptr) {
      gDefaultLocalesHashT = uhash_open(uhash_hashChars, uhash_compareChars, nullptr, &status);
      if (U_FAILURE(status)) {
          return gDefaultLocale;
      }
      uhash_setValueDeleter(gDefaultLocalesHashT, deleteLocale);
      ucln_common_registerCleanup(UCLN_COMMON_LOCALE, locale_cleanup);
  }

  Locale* newDefault = static_cast<Locale*>(uhash_get(gDefaultLocalesHashT, localeNameBuf.data()));
  if (newDefault == nullptr) {
      newDefault = new Locale(Locale::eBOGUS);
      if (newDefault == nullptr) {
          status = U_MEMORY_ALLOCATION_ERROR;
          return gDefaultLocale;
      }
      newDefault->init(localeNameBuf.data(), false);
      uhash_put(gDefaultLocalesHashT, const_cast<char*>(newDefault->getName()), newDefault, &status);
      if (U_FAILURE(status)) {
          return gDefaultLocale;
      }
  }
  gDefaultLocale = newDefault;
  return gDefaultLocale;
218}

220U_NAMESPACE_END}

222/* sfb 07/21/99 */
223U_CFUNCextern "C" void
224locale_set_default(const char *id)
225{
  U_NAMESPACE_USEusing namespace icu_78;
  UErrorCode status = U_ZERO_ERROR;
  locale_set_default_internal(id, status);
229}
230/* end */

232U_CFUNCextern "C" const char *
233locale_get_default()
234{
  U_NAMESPACE_USEusing namespace icu_78;
  return Locale::getDefault().getName();
237}

239namespace {

241template <auto FIELD, typename T>
242void copyToArray(std::string_view sv, T* that) {
  auto& field = that->*FIELD;
  constexpr size_t capacity = std::extent_v<std::remove_reference_t<decltype(field)>>;
  static_assert(capacity > 0);
  if (!sv.empty()) {
      U_ASSERT(sv.size() < capacity)(static_cast <bool> (sv.size() < capacity) ? void (0
) : __assert_fail ("sv.size() < capacity", __builtin_FILE (
), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      uprv_memcpy(field, sv.data(), sv.size())do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (field != __null) ? void (0) : __assert_fail
 ("field != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (sv.data() !=
 __null) ? void (0) : __assert_fail ("sv.data() != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memcpy(field, sv.data(), sv.size()); } while
 (false);
  }
  field[sv.size()] = '\0';
251}

253} // namespace

255U_NAMESPACE_BEGINnamespace icu_78 {

257void Locale::Nest::init(std::string_view language,
                      std::string_view script,
                      std::string_view region,
                      uint8_t variantBegin) {
  copyToArray<&Nest::language>(language, this);
  copyToArray<&Nest::script>(script, this);
  copyToArray<&Nest::region>(region, this);
  this->variantBegin = variantBegin;
265}

267Locale::Nest::Nest(Heap&& heap, uint8_t variantBegin) {
  // When moving from Heap to Nest the language field can be left untouched
  // (as it has the same offset in both) and only the script and region fields
  // need to be copied to their new locations, which is safe to do because the
  // new locations come before the old locations in memory and don't overlap.
  static_assert(offsetof(Nest, region)__builtin_offsetof(Nest, region) <= offsetof(Heap, script)__builtin_offsetof(Heap, script));
  static_assert(offsetof(Nest, variantBegin)__builtin_offsetof(Nest, variantBegin) <= offsetof(Heap, region)__builtin_offsetof(Heap, region));
  U_ASSERT(this == reinterpret_cast<Nest*>(&heap))(static_cast <bool> (this == reinterpret_cast<Nest*>
(&heap)) ? void (0) : __assert_fail ("this == reinterpret_cast<Nest*>(&heap)"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
  copyToArray<&Nest::script>(heap.script, this);
  copyToArray<&Nest::region>(heap.region, this);
  this->variantBegin = variantBegin;
  *this->baseName = '\0';
279}

281struct Locale::Heap::Alloc : public UMemory {
  FixedString fullName;
  FixedString baseName;
  int32_t variantBegin;

  const char* getVariant() const { return variantBegin == 0 ? "" : getBaseName() + variantBegin; }
  const char* getFullName() const { return fullName.data(); }
  const char* getBaseName() const {
      if (baseName.isEmpty()) {
          if (const char* name = fullName.data(); *name != '@') {
              return name;
          }
      }
      return baseName.data();
  }

  Alloc(int32_t variantBegin) : fullName(), baseName(), variantBegin(variantBegin) {}

  Alloc(const Alloc& other, UErrorCode& status)
      : fullName(), baseName(), variantBegin(other.variantBegin) {
      if (U_SUCCESS(status)) {
          if (!other.fullName.isEmpty()) {
              fullName = other.fullName;
              if (fullName.isEmpty()) {
                  status = U_MEMORY_ALLOCATION_ERROR;
              } else {
                  if (!other.baseName.isEmpty()) {
                      baseName = other.baseName;
                      if (baseName.isEmpty()) {
                          status = U_MEMORY_ALLOCATION_ERROR;
                      }
                  }
              }
          }
      }
  }

  // Move should be done on the owner of the pointer to this object.
  Alloc(Alloc&&) noexcept = delete;

  ~Alloc() = default;
322};

324const char* Locale::Heap::getVariant() const { return ptr->getVariant(); }
325const char* Locale::Heap::getFullName() const { return ptr->getFullName(); }
326const char* Locale::Heap::getBaseName() const { return ptr->getBaseName(); }

328Locale::Heap::Heap(std::string_view language,
                 std::string_view script,
                 std::string_view region,
                 int32_t variantBegin) {
  ptr = new Alloc(variantBegin);
  if (ptr == nullptr) {
      type = eBOGUS;
  } else {
      type = eHEAP;
      copyToArray<&Heap::language>(language, this);
      copyToArray<&Heap::script>(script, this);
      copyToArray<&Heap::region>(region, this);
  }
341}

343Locale::Heap::~Heap() {
  U_ASSERT(type == eHEAP)(static_cast <bool> (type == eHEAP) ? void (0) : __assert_fail
 ("type == eHEAP", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
  delete ptr;
346}

348Locale::Heap& Locale::Heap::operator=(const Heap& other) {
  U_ASSERT(type == eBOGUS)(static_cast <bool> (type == eBOGUS) ? void (0) : __assert_fail
 ("type == eBOGUS", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
  UErrorCode status = U_ZERO_ERROR;
  ptr = new Alloc(*other.ptr, status);
  if (ptr == nullptr || U_FAILURE(status)) {
      delete ptr;
  } else {
      type = eHEAP;
      uprv_memcpy(language, other.language, sizeof language)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (language != __null) ? void (0) :
 __assert_fail ("language != __null", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__)); (static_cast <bool
> (other.language != __null) ? void (0) : __assert_fail ("other.language != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); clang diagnostic pop
 :: memcpy(language, other.language,
 sizeof language); } while (false);
      uprv_memcpy(script, other.script, sizeof script)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (script != __null) ? void (0) : __assert_fail
 ("script != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (other.script
 != __null) ? void (0) : __assert_fail ("other.script != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); clang diagnostic pop
 :: memcpy(script, other.script, sizeof
 script); } while (false);
      uprv_memcpy(region, other.region, sizeof region)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (region != __null) ? void (0) : __assert_fail
 ("region != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (other.region
 != __null) ? void (0) : __assert_fail ("other.region != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); clang diagnostic pop
 :: memcpy(region, other.region, sizeof
 region); } while (false);
  }
  return *this;
361}

363Locale::Heap& Locale::Heap::operator=(Heap&& other) noexcept {
  U_ASSERT(type == eBOGUS)(static_cast <bool> (type == eBOGUS) ? void (0) : __assert_fail
 ("type == eBOGUS", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
  ptr = other.ptr;
  type = eHEAP;
  other.type = eBOGUS;
  uprv_memcpy(language, other.language, sizeof language)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (language != __null) ? void (0) :
 __assert_fail ("language != __null", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__)); (static_cast <bool
> (other.language != __null) ? void (0) : __assert_fail ("other.language != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); clang diagnostic pop
 :: memcpy(language, other.language,
 sizeof language); } while (false);
  uprv_memcpy(script, other.script, sizeof script)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (script != __null) ? void (0) : __assert_fail
 ("script != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (other.script
 != __null) ? void (0) : __assert_fail ("other.script != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); clang diagnostic pop
 :: memcpy(script, other.script, sizeof
 script); } while (false);
  uprv_memcpy(region, other.region, sizeof region)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (region != __null) ? void (0) : __assert_fail
 ("region != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (other.region
 != __null) ? void (0) : __assert_fail ("other.region != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); clang diagnostic pop
 :: memcpy(region, other.region, sizeof
 region); } while (false);
  return *this;
372}

374template <typename BogusFn, typename NestFn, typename HeapFn, typename... Args>
375auto Locale::Payload::visit(BogusFn bogusFn, NestFn nestFn, HeapFn heapFn, Args... args) const {
  switch (type) {
      case eBOGUS:
          return bogusFn(args...);
      case eNEST:
          return nestFn(nest, args...);
      case eHEAP:
          return heapFn(heap, args...);
      default:
          UPRV_UNREACHABLE_EXITabort();
  };
386}

388void Locale::Payload::copy(const Payload& other) {
  other.visit([](Payload*) {},
              [](const Nest& nest, Payload* dst) { dst->nest = nest; },
              [](const Heap& heap, Payload* dst) { dst->heap = heap; },
              this);
393}

395void Locale::Payload::move(Payload&& other) noexcept {
  other.visit(
      [](Payload*) {},
      [](const Nest& nest, Payload* dst) { dst->nest = nest; },
      [](const Heap& heap, Payload* dst) { dst->heap = std::move(const_cast<Heap&>(heap)); },
      this);
401}

403Locale::Payload::~Payload() {
  if (type == eHEAP) { heap.~Heap(); }
405}

407Locale::Payload::Payload(const Payload& other) : type{eBOGUS} { copy(other); }
408Locale::Payload::Payload(Payload&& other) noexcept : type{eBOGUS} { move(std::move(other)); }

410Locale::Payload& Locale::Payload::operator=(const Payload& other) {
  if (this != &other) {
      setToBogus();
      copy(other);
  }
  return *this;
416}

418Locale::Payload& Locale::Payload::operator=(Payload&& other) noexcept {
  if (this != &other) {
      setToBogus();
      move(std::move(other));
  }
  return *this;
424}

426void Locale::Payload::setToBogus() {
  this->~Payload();
  type = eBOGUS;
429}

431template <typename T, typename... Args> T& Locale::Payload::emplace(Args&&... args) {
  if constexpr (std::is_same_v<T, Nest>) {
      this->~Payload();
      ::new (&nest) Nest(std::forward<Args>(args)...);
      return nest;
  }
  if constexpr (std::is_same_v<T, Heap>) {
      U_ASSERT(type != eHEAP)(static_cast <bool> (type != eHEAP) ? void (0) : __assert_fail
 ("type != eHEAP", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
      ::new (&heap) Heap(std::forward<Args>(args)...);
      return heap;
  }
442}

444template <> Locale::Nest* Locale::Payload::get() { return type == eNEST ? &nest : nullptr; }
445template <> Locale::Heap* Locale::Payload::get() { return type == eHEAP ? &heap : nullptr; }

447UOBJECT_DEFINE_RTTI_IMPLEMENTATION(Locale)UClassID Locale::getStaticClassID() { static char classID = 0
; return (UClassID)&classID; } UClassID Locale::getDynamicClassID
() const { return Locale::getStaticClassID(); }

449/*Character separating the posix id fields*/
450// '_'
451// In the platform codepage.
452#define SEP_CHAR'_' '_'
453#define NULL_CHAR'\0' '\0'

455Locale::~Locale() = default;

457Locale::Locale()
  : UObject(), payload()
459{
  init(nullptr, false);
461}

463/*
* Internal constructor to allow construction of a locale object with
*   NO side effects.   (Default constructor tries to get
*   the default locale.)
*/
468Locale::Locale(Locale::ELocaleType)
  : UObject(), payload()
470{
471}


474Locale::Locale( const   char * newLanguage,
              const   char * newCountry,
              const   char * newVariant,
              const   char * newKeywords)
  : UObject(), payload()
479{
  if( (newLanguage==nullptr) && (newCountry == nullptr) && (newVariant == nullptr) )
  {
      init(nullptr, false); /* shortcut */
  }
  else
  {
      UErrorCode status = U_ZERO_ERROR;
      int32_t lsize = 0;
      int32_t csize = 0;
      int32_t vsize = 0;
      int32_t ksize = 0;

      // Check the sizes of the input strings.

      // Language
      if ( newLanguage != nullptr )
      {
          lsize = static_cast<int32_t>(uprv_strlen(newLanguage):: strlen(newLanguage));
          if ( lsize < 0 || lsize > ULOC_STRING_LIMIT357913941 ) { // int32 wrap
              return;
          }
      }

      CharString togo(newLanguage, lsize, status); // start with newLanguage

      // _Country
      if ( newCountry != nullptr )
      {
          csize = static_cast<int32_t>(uprv_strlen(newCountry):: strlen(newCountry));
          if ( csize < 0 || csize > ULOC_STRING_LIMIT357913941 ) { // int32 wrap
              return;
          }
      }

      // _Variant
      if ( newVariant != nullptr )
      {
          // remove leading _'s
          while(newVariant[0] == SEP_CHAR'_')
          {
              newVariant++;
          }

          // remove trailing _'s
          vsize = static_cast<int32_t>(uprv_strlen(newVariant):: strlen(newVariant));
          if ( vsize < 0 || vsize > ULOC_STRING_LIMIT357913941 ) { // int32 wrap
              return;
          }
          while( (vsize>1) && (newVariant[vsize-1] == SEP_CHAR'_') )
          {
              vsize--;
          }
      }

      if ( newKeywords != nullptr)
      {
          ksize = static_cast<int32_t>(uprv_strlen(newKeywords):: strlen(newKeywords));
          if ( ksize < 0 || ksize > ULOC_STRING_LIMIT357913941 ) {
            return;
          }
      }

      // We've checked the input sizes, now build up the full locale string..

      // newLanguage is already copied

      if ( ( vsize != 0 ) || (csize != 0) )  // at least:  __v
      {                                      //            ^
          togo.append(SEP_CHAR'_', status);
      }

      if ( csize != 0 )
      {
          togo.append(newCountry, status);
      }

      if ( vsize != 0)
      {
          togo.append(SEP_CHAR'_', status)
              .append(newVariant, vsize, status);
      }

      if ( ksize != 0)
      {
          if (uprv_strchr(newKeywords, '='):: strchr(newKeywords, '=')) {
              togo.append('@', status); /* keyword parsing */
          }
          else {
              togo.append('_', status); /* Variant parsing with a script */
              if ( vsize == 0) {
                  togo.append('_', status); /* No country found */
              }
          }
          togo.append(newKeywords, status);
      }

      if (U_FAILURE(status)) {
          // Something went wrong with appending, etc.
          return;
      }
      // Parse it, because for example 'language' might really be a complete
      // string.
      init(togo.data(), false);
  }
584}

586Locale::Locale(const Locale&) = default;
587Locale::Locale(Locale&&) noexcept = default;

589Locale& Locale::operator=(const Locale&) = default;
590Locale& Locale::operator=(Locale&&) noexcept = default;

592Locale *
593Locale::clone() const {
  return new Locale(*this);
595}

597bool
598Locale::operator==( const   Locale& other) const
599{
  return uprv_strcmp(other.getName(), getName()):: strcmp(other.getName(), getName()) == 0;
601}

603namespace {

605UInitOnce gKnownCanonicalizedInitOnce {};
606UHashtable *gKnownCanonicalized = nullptr;

608constexpr const char* KNOWN_CANONICALIZED[] = {
  "c",
  // Commonly used locales known are already canonicalized
  "af", "af_ZA", "am", "am_ET", "ar", "ar_001", "as", "as_IN", "az", "az_AZ",
  "be", "be_BY", "bg", "bg_BG", "bn", "bn_IN", "bs", "bs_BA", "ca", "ca_ES",
  "cs", "cs_CZ", "cy", "cy_GB", "da", "da_DK", "de", "de_DE", "el", "el_GR",
  "en", "en_GB", "en_US", "es", "es_419", "es_ES", "et", "et_EE", "eu",
  "eu_ES", "fa", "fa_IR", "fi", "fi_FI", "fil", "fil_PH", "fr", "fr_FR",
  "ga", "ga_IE", "gl", "gl_ES", "gu", "gu_IN", "he", "he_IL", "hi", "hi_IN",
  "hr", "hr_HR", "hu", "hu_HU", "hy", "hy_AM", "id", "id_ID", "is", "is_IS",
  "it", "it_IT", "ja", "ja_JP", "jv", "jv_ID", "ka", "ka_GE", "kk", "kk_KZ",
  "km", "km_KH", "kn", "kn_IN", "ko", "ko_KR", "ky", "ky_KG", "lo", "lo_LA",
  "lt", "lt_LT", "lv", "lv_LV", "mk", "mk_MK", "ml", "ml_IN", "mn", "mn_MN",
  "mr", "mr_IN", "ms", "ms_MY", "my", "my_MM", "nb", "nb_NO", "ne", "ne_NP",
  "nl", "nl_NL", "no", "or", "or_IN", "pa", "pa_IN", "pl", "pl_PL", "ps", "ps_AF",
  "pt", "pt_BR", "pt_PT", "ro", "ro_RO", "ru", "ru_RU", "sd", "sd_IN", "si",
  "si_LK", "sk", "sk_SK", "sl", "sl_SI", "so", "so_SO", "sq", "sq_AL", "sr",
  "sr_Cyrl_RS", "sr_Latn", "sr_RS", "sv", "sv_SE", "sw", "sw_TZ", "ta",
  "ta_IN", "te", "te_IN", "th", "th_TH", "tk", "tk_TM", "tr", "tr_TR", "uk",
  "uk_UA", "ur", "ur_PK", "uz", "uz_UZ", "vi", "vi_VN", "yue", "yue_Hant",
  "yue_Hant_HK", "yue_HK", "zh", "zh_CN", "zh_Hans", "zh_Hans_CN", "zh_Hant",
  "zh_Hant_TW", "zh_TW", "zu", "zu_ZA"
630};

632UBool U_CALLCONV cleanupKnownCanonicalized() {
  gKnownCanonicalizedInitOnce.reset();
  if (gKnownCanonicalized) { uhash_close(gKnownCanonicalized); }
  return true;
636}

638void U_CALLCONV loadKnownCanonicalized(UErrorCode &status) {
  ucln_common_registerCleanup(UCLN_COMMON_LOCALE_KNOWN_CANONICALIZED,
                              cleanupKnownCanonicalized);
  LocalUHashtablePointer newKnownCanonicalizedMap(
      uhash_open(uhash_hashChars, uhash_compareChars, nullptr, &status));
  for (int32_t i = 0;
          U_SUCCESS(status) && i < UPRV_LENGTHOF(KNOWN_CANONICALIZED)(int32_t)(sizeof(KNOWN_CANONICALIZED)/sizeof((KNOWN_CANONICALIZED
)[0]));
          i++) {
      uhash_puti(newKnownCanonicalizedMap.getAlias(),
                 (void*)KNOWN_CANONICALIZED[i],
                 1, &status);
  }
  if (U_FAILURE(status)) {
      return;
  }

  gKnownCanonicalized = newKnownCanonicalizedMap.orphan();
655}

657class AliasData;

659/**
* A Builder class to build the alias data.
*/
662class AliasDataBuilder {
663public:
  AliasDataBuilder() {
  }

  // Build the AliasData from resource.
  AliasData* build(UErrorCode &status);

670private:
  void readAlias(UResourceBundle* alias,
                 UniqueCharStrings* strings,
                 LocalMemory<const char*>& types,
                 LocalMemory<int32_t>& replacementIndexes,
                 int32_t &length,
                 void (*checkType)(const char* type),
                 void (*checkReplacement)(const UChar* replacement),
                 UErrorCode &status);

  // Read the languageAlias data from alias to
  // strings+types+replacementIndexes
  // The number of record will be stored into length.
  // Allocate length items for types, to store the type field.
  // Allocate length items for replacementIndexes,
  // to store the index in the strings for the replacement script.
  void readLanguageAlias(UResourceBundle* alias,
                         UniqueCharStrings* strings,
                         LocalMemory<const char*>& types,
                         LocalMemory<int32_t>& replacementIndexes,
                         int32_t &length,
                         UErrorCode &status);

  // Read the scriptAlias data from alias to
  // strings+types+replacementIndexes
  // Allocate length items for types, to store the type field.
  // Allocate length items for replacementIndexes,
  // to store the index in the strings for the replacement script.
  void readScriptAlias(UResourceBundle* alias,
                       UniqueCharStrings* strings,
                       LocalMemory<const char*>& types,
                       LocalMemory<int32_t>& replacementIndexes,
                       int32_t &length, UErrorCode &status);

  // Read the territoryAlias data from alias to
  // strings+types+replacementIndexes
  // Allocate length items for types, to store the type field.
  // Allocate length items for replacementIndexes,
  // to store the index in the strings for the replacement script.
  void readTerritoryAlias(UResourceBundle* alias,
                          UniqueCharStrings* strings,
                          LocalMemory<const char*>& types,
                          LocalMemory<int32_t>& replacementIndexes,
                          int32_t &length, UErrorCode &status);

  // Read the variantAlias data from alias to
  // strings+types+replacementIndexes
  // Allocate length items for types, to store the type field.
  // Allocate length items for replacementIndexes,
  // to store the index in the strings for the replacement variant.
  void readVariantAlias(UResourceBundle* alias,
                        UniqueCharStrings* strings,
                        LocalMemory<const char*>& types,
                        LocalMemory<int32_t>& replacementIndexes,
                        int32_t &length, UErrorCode &status);

  // Read the subdivisionAlias data from alias to
  // strings+types+replacementIndexes
  // Allocate length items for types, to store the type field.
  // Allocate length items for replacementIndexes,
  // to store the index in the strings for the replacement variant.
  void readSubdivisionAlias(UResourceBundle* alias,
                        UniqueCharStrings* strings,
                        LocalMemory<const char*>& types,
                        LocalMemory<int32_t>& replacementIndexes,
                        int32_t &length, UErrorCode &status);
736};

738/**
* A class to hold the Alias Data.
*/
741class AliasData : public UMemory {
742public:
  static const AliasData* singleton(UErrorCode& status) {
      if (U_FAILURE(status)) {
          // Do not get into loadData if the status already has error.
          return nullptr;
      }
      umtx_initOnce(AliasData::gInitOnce, &AliasData::loadData, status);
      return gSingleton;
  }

  const CharStringMap& languageMap() const { return language; }
  const CharStringMap& scriptMap() const { return script; }
  const CharStringMap& territoryMap() const { return territory; }
  const CharStringMap& variantMap() const { return variant; }
  const CharStringMap& subdivisionMap() const { return subdivision; }

  static void U_CALLCONV loadData(UErrorCode &status);
  static UBool U_CALLCONV cleanup();

  static UInitOnce gInitOnce;

763private:
  AliasData(CharStringMap languageMap,
            CharStringMap scriptMap,
            CharStringMap territoryMap,
            CharStringMap variantMap,
            CharStringMap subdivisionMap,
            CharString* strings)
      : language(std::move(languageMap)),
        script(std::move(scriptMap)),
        territory(std::move(territoryMap)),
        variant(std::move(variantMap)),
        subdivision(std::move(subdivisionMap)),
        strings(strings) {
  }

  ~AliasData() {
      delete strings;
  }

  static const AliasData* gSingleton;

  CharStringMap language;
  CharStringMap script;
  CharStringMap territory;
  CharStringMap variant;
  CharStringMap subdivision;
  CharString* strings;

  friend class AliasDataBuilder;
792};


795const AliasData* AliasData::gSingleton = nullptr;
796UInitOnce AliasData::gInitOnce {};

798UBool U_CALLCONV
799AliasData::cleanup()
800{
  gInitOnce.reset();
  delete gSingleton;
  return true;
804}

806void
807AliasDataBuilder::readAlias(
      UResourceBundle* alias,
      UniqueCharStrings* strings,
      LocalMemory<const char*>& types,
      LocalMemory<int32_t>& replacementIndexes,
      int32_t &length,
      void (*checkType)(const char* type),
      void (*checkReplacement)(const UChar* replacement),
      UErrorCode &status) {
  if (U_FAILURE(status)) {
12
←
Taking false branch→
      return;
  }
  length = ures_getSize(alias);
  const char** rawTypes = types.allocateInsteadAndCopy(length);
  if (rawTypes == nullptr) {
13
←
Taking true branch→
      status = U_MEMORY_ALLOCATION_ERROR;
      return;
14
←
Returning without writing to 'types.ptr'→
  }
  int32_t* rawIndexes = replacementIndexes.allocateInsteadAndCopy(length);
  if (rawIndexes == nullptr) {
      status = U_MEMORY_ALLOCATION_ERROR;
      return;
  }
  for (int i = 0; U_SUCCESS(status) && ures_hasNext(alias); i++) {
      LocalUResourceBundlePointer res(
          ures_getNextResource(alias, nullptr, &status));
      const char* aliasFrom = ures_getKey(res.getAlias());
      const UChar* aliasTo =
          ures_getStringByKey(res.getAlias(), "replacement", nullptr, &status);
      if (U_FAILURE(status)) return;

      checkType(aliasFrom);
      checkReplacement(aliasTo);

      rawTypes[i] = aliasFrom;
      rawIndexes[i] = strings->add(aliasTo, status);
  }
844}

846/**
* Read the languageAlias data from alias to strings+types+replacementIndexes.
* Allocate length items for types, to store the type field. Allocate length
* items for replacementIndexes, to store the index in the strings for the
* replacement language.
*/
852void
853AliasDataBuilder::readLanguageAlias(
      UResourceBundle* alias,
      UniqueCharStrings* strings,
      LocalMemory<const char*>& types,
      LocalMemory<int32_t>& replacementIndexes,
      int32_t &length,
      UErrorCode &status)
860{
  return readAlias(
11
←
Calling 'AliasDataBuilder::readAlias'→
15
←
Returning from 'AliasDataBuilder::readAlias'→
16
←
Returning without writing to 'types.ptr'→
      alias, strings, types, replacementIndexes, length,
863#if U_DEBUG1
      [](const char* type) {
          // Assert the aliasFrom only contains the following possibilities
          // language_REGION_variant
          // language_REGION
          // language_variant
          // language
          // und_variant
          Locale test(type);
          // Assert no script in aliasFrom
          U_ASSERT(test.getScript()[0] == '\0')(static_cast <bool> (test.getScript()[0] == '\0') ? void
 (0) : __assert_fail ("test.getScript()[0] == '\\0'", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
          // Assert when language is und, no REGION in aliasFrom.
          U_ASSERT(test.getLanguage()[0] != '\0' || test.getCountry()[0] == '\0')(static_cast <bool> (test.getLanguage()[0] != '\0' || test
.getCountry()[0] == '\0') ? void (0) : __assert_fail ("test.getLanguage()[0] != '\\0' || test.getCountry()[0] == '\\0'"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
      },
877#else
      [](const char*) {},
879#endif
      [](const UChar*) {}, status);
881}

883/**
* Read the scriptAlias data from alias to strings+types+replacementIndexes.
* Allocate length items for types, to store the type field. Allocate length
* items for replacementIndexes, to store the index in the strings for the
* replacement script.
*/
889void
890AliasDataBuilder::readScriptAlias(
      UResourceBundle* alias,
      UniqueCharStrings* strings,
      LocalMemory<const char*>& types,
      LocalMemory<int32_t>& replacementIndexes,
      int32_t &length,
      UErrorCode &status)
897{
  return readAlias(
      alias, strings, types, replacementIndexes, length,
900#if U_DEBUG1
      [](const char* type) {
          U_ASSERT(uprv_strlen(type) == 4)(static_cast <bool> (:: strlen(type) == 4) ? void (0) :
 __assert_fail (":: strlen(type) == 4", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__));
      },
      [](const UChar* replacement) {
          U_ASSERT(u_strlen(replacement) == 4)(static_cast <bool> (u_strlen(replacement) == 4) ? void
 (0) : __assert_fail ("u_strlen(replacement) == 4", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
      },
907#else
      [](const char*) {},
      [](const UChar*) { },
910#endif
      status);
912}

914/**
* Read the territoryAlias data from alias to strings+types+replacementIndexes.
* Allocate length items for types, to store the type field. Allocate length
* items for replacementIndexes, to store the index in the strings for the
* replacement regions.
*/
920void
921AliasDataBuilder::readTerritoryAlias(
      UResourceBundle* alias,
      UniqueCharStrings* strings,
      LocalMemory<const char*>& types,
      LocalMemory<int32_t>& replacementIndexes,
      int32_t &length,
      UErrorCode &status)
928{
  return readAlias(
      alias, strings, types, replacementIndexes, length,
931#if U_DEBUG1
      [](const char* type) {
          U_ASSERT(uprv_strlen(type) == 2 || uprv_strlen(type) == 3)(static_cast <bool> (:: strlen(type) == 2 || :: strlen(
type) == 3) ? void (0) : __assert_fail (":: strlen(type) == 2 || :: strlen(type) == 3"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
      },
935#else
      [](const char*) {},
937#endif
      [](const UChar*) { },
      status);
940}

942/**
* Read the variantAlias data from alias to strings+types+replacementIndexes.
* Allocate length items for types, to store the type field. Allocate length
* items for replacementIndexes, to store the index in the strings for the
* replacement variant.
*/
948void
949AliasDataBuilder::readVariantAlias(
      UResourceBundle* alias,
      UniqueCharStrings* strings,
      LocalMemory<const char*>& types,
      LocalMemory<int32_t>& replacementIndexes,
      int32_t &length,
      UErrorCode &status)
956{
  return readAlias(
      alias, strings, types, replacementIndexes, length,
959#if U_DEBUG1
      [](const char* type) {
          U_ASSERT(uprv_strlen(type) >= 4 && uprv_strlen(type) <= 8)(static_cast <bool> (:: strlen(type) >= 4 &&
 :: strlen(type) <= 8) ? void (0) : __assert_fail (":: strlen(type) >= 4 && :: strlen(type) <= 8"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
          U_ASSERT(uprv_strlen(type) != 4 ||(static_cast <bool> (:: strlen(type) != 4 || (type[0] >=
 '0' && type[0] <= '9')) ? void (0) : __assert_fail
 (":: strlen(type) != 4 || (type[0] >= '0' && type[0] <= '9')"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
                   (type[0] >= '0' && type[0] <= '9'))(static_cast <bool> (:: strlen(type) != 4 || (type[0] >=
 '0' && type[0] <= '9')) ? void (0) : __assert_fail
 (":: strlen(type) != 4 || (type[0] >= '0' && type[0] <= '9')"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
      },
      [](const UChar* replacement) {
          int32_t len = u_strlen(replacement);
          U_ASSERT(len >= 4 && len <= 8)(static_cast <bool> (len >= 4 && len <= 8
) ? void (0) : __assert_fail ("len >= 4 && len <= 8"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
          U_ASSERT(len != 4 ||(static_cast <bool> (len != 4 || (*replacement >= u'0'
 && *replacement <= u'9')) ? void (0) : __assert_fail
 ("len != 4 || (*replacement >= u'0' && *replacement <= u'9')"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
                   (*replacement >= u'0' &&(static_cast <bool> (len != 4 || (*replacement >= u'0'
 && *replacement <= u'9')) ? void (0) : __assert_fail
 ("len != 4 || (*replacement >= u'0' && *replacement <= u'9')"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
                    *replacement <= u'9'))(static_cast <bool> (len != 4 || (*replacement >= u'0'
 && *replacement <= u'9')) ? void (0) : __assert_fail
 ("len != 4 || (*replacement >= u'0' && *replacement <= u'9')"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
      },
972#else
      [](const char*) {},
      [](const UChar*) { },
975#endif
      status);
977}

979/**
* Read the subdivisionAlias data from alias to strings+types+replacementIndexes.
* Allocate length items for types, to store the type field. Allocate length
* items for replacementIndexes, to store the index in the strings for the
* replacement regions.
*/
985void
986AliasDataBuilder::readSubdivisionAlias(
      UResourceBundle* alias,
      UniqueCharStrings* strings,
      LocalMemory<const char*>& types,
      LocalMemory<int32_t>& replacementIndexes,
      int32_t &length,
      UErrorCode &status)
993{
  return readAlias(
      alias, strings, types, replacementIndexes, length,
996#if U_DEBUG1
      [](const char* type) {
          U_ASSERT(uprv_strlen(type) >= 3 && uprv_strlen(type) <= 8)(static_cast <bool> (:: strlen(type) >= 3 &&
 :: strlen(type) <= 8) ? void (0) : __assert_fail (":: strlen(type) >= 3 && :: strlen(type) <= 8"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
      },
1000#else
      [](const char*) {},
1002#endif
      [](const UChar*) { },
      status);
1005}

1007/**
* Initializes the alias data from the ICU resource bundles. The alias data
* contains alias of language, country, script and variants.
*
* If the alias data has already loaded, then this method simply returns without
* doing anything meaningful.
*/
1014void U_CALLCONV
1015AliasData::loadData(UErrorCode &status)
1016{
1017#ifdef LOCALE_CANONICALIZATION_DEBUG
  UDate start = uprv_getRawUTCtime();
1019#endif  // LOCALE_CANONICALIZATION_DEBUG
  ucln_common_registerCleanup(UCLN_COMMON_LOCALE_ALIAS, cleanup);
  AliasDataBuilder builder;
  gSingleton = builder.build(status);
1023#ifdef LOCALE_CANONICALIZATION_DEBUG
  UDate end = uprv_getRawUTCtime();
  printf("AliasData::loadData took total %f ms\n", end - start);
1026#endif  // LOCALE_CANONICALIZATION_DEBUG
1027}

1029/**
* Build the alias data from resources.
*/
1032AliasData*
1033AliasDataBuilder::build(UErrorCode &status) {
  if (U_FAILURE(status)) { return nullptr; }
1
Taking false branch→

  LocalUResourceBundlePointer metadata(
      ures_openDirect(nullptr, "metadata", &status));
  LocalUResourceBundlePointer metadataAlias(
      ures_getByKey(metadata.getAlias(), "alias", nullptr, &status));
  LocalUResourceBundlePointer languageAlias(
      ures_getByKey(metadataAlias.getAlias(), "language", nullptr, &status));
  LocalUResourceBundlePointer scriptAlias(
      ures_getByKey(metadataAlias.getAlias(), "script", nullptr, &status));
  LocalUResourceBundlePointer territoryAlias(
      ures_getByKey(metadataAlias.getAlias(), "territory", nullptr, &status));
  LocalUResourceBundlePointer variantAlias(
      ures_getByKey(metadataAlias.getAlias(), "variant", nullptr, &status));
  LocalUResourceBundlePointer subdivisionAlias(
      ures_getByKey(metadataAlias.getAlias(), "subdivision", nullptr, &status));

  if (U_FAILURE(status)) {
2
←
Taking false branch→
      return nullptr;
  }
  int32_t languagesLength = 0, scriptLength = 0, territoryLength = 0,
          variantLength = 0, subdivisionLength = 0;

  // Read the languageAlias into languageTypes, languageReplacementIndexes
  // and strings
  UniqueCharStrings strings(status);
  LocalMemory<const char*> languageTypes;
3
←
Passing null pointer value via 1st parameter 'p'→
4
←
Calling default constructor for 'LocalMemory<const char *>'→
9
←
Returning from default constructor for 'LocalMemory<const char *>'→
  LocalMemory<int32_t> languageReplacementIndexes;
  readLanguageAlias(languageAlias.getAlias(),
10
←
Calling 'AliasDataBuilder::readLanguageAlias'→
17
←
Returning from 'AliasDataBuilder::readLanguageAlias'→
                    &strings,
                    languageTypes,
                    languageReplacementIndexes,
                    languagesLength,
                    status);

  // Read the scriptAlias into scriptTypes, scriptReplacementIndexes
  // and strings
  LocalMemory<const char*> scriptTypes;
  LocalMemory<int32_t> scriptReplacementIndexes;
  readScriptAlias(scriptAlias.getAlias(),
                  &strings,
                  scriptTypes,
                  scriptReplacementIndexes,
                  scriptLength,
                  status);

  // Read the territoryAlias into territoryTypes, territoryReplacementIndexes
  // and strings
  LocalMemory<const char*> territoryTypes;
  LocalMemory<int32_t> territoryReplacementIndexes;
  readTerritoryAlias(territoryAlias.getAlias(),
                     &strings,
                     territoryTypes,
                     territoryReplacementIndexes,
                     territoryLength, status);

  // Read the variantAlias into variantTypes, variantReplacementIndexes
  // and strings
  LocalMemory<const char*> variantTypes;
  LocalMemory<int32_t> variantReplacementIndexes;
  readVariantAlias(variantAlias.getAlias(),
                   &strings,
                   variantTypes,
                   variantReplacementIndexes,
                   variantLength, status);

  // Read the subdivisionAlias into subdivisionTypes, subdivisionReplacementIndexes
  // and strings
  LocalMemory<const char*> subdivisionTypes;
  LocalMemory<int32_t> subdivisionReplacementIndexes;
  readSubdivisionAlias(subdivisionAlias.getAlias(),
                       &strings,
                       subdivisionTypes,
                       subdivisionReplacementIndexes,
                       subdivisionLength, status);

  if (U_FAILURE(status)) {
18
←
Taking false branch→
      return nullptr;
  }

  // We can only use strings after freeze it.
  strings.freeze();

  // Build the languageMap from languageTypes & languageReplacementIndexes
  CharStringMap languageMap(490, status);
  for (int32_t i = 0; U_SUCCESS(status) && i18.1
'i' is < 'languagesLength'
1
'i' is < 'languagesLength'
1
'i' is < 'languagesLength'
 < languagesLength; i++) {
19
←
Loop condition is true.  Entering loop body→
      languageMap.put(languageTypes[i],
20
←
Calling 'LocalMemory::operator[]'→
                      strings.get(languageReplacementIndexes[i]),
                      status);
  }

  // Build the scriptMap from scriptTypes & scriptReplacementIndexes
  CharStringMap scriptMap(1, status);
  for (int32_t i = 0; U_SUCCESS(status) && i < scriptLength; i++) {
      scriptMap.put(scriptTypes[i],
                    strings.get(scriptReplacementIndexes[i]),
                    status);
  }

  // Build the territoryMap from territoryTypes & territoryReplacementIndexes
  CharStringMap territoryMap(650, status);
  for (int32_t i = 0; U_SUCCESS(status) && i < territoryLength; i++) {
      territoryMap.put(territoryTypes[i],
                       strings.get(territoryReplacementIndexes[i]),
                       status);
  }

  // Build the variantMap from variantTypes & variantReplacementIndexes.
  CharStringMap variantMap(2, status);
  for (int32_t i = 0; U_SUCCESS(status) && i < variantLength; i++) {
      variantMap.put(variantTypes[i],
                     strings.get(variantReplacementIndexes[i]),
                     status);
  }

  // Build the subdivisionMap from subdivisionTypes & subdivisionReplacementIndexes.
  CharStringMap subdivisionMap(2, status);
  for (int32_t i = 0; U_SUCCESS(status) && i < subdivisionLength; i++) {
      subdivisionMap.put(subdivisionTypes[i],
                     strings.get(subdivisionReplacementIndexes[i]),
                     status);
  }

  if (U_FAILURE(status)) {
      return nullptr;
  }

  // copy hashtables
  auto *data = new AliasData(
      std::move(languageMap),
      std::move(scriptMap),
      std::move(territoryMap),
      std::move(variantMap),
      std::move(subdivisionMap),
      strings.orphanCharStrings());

  if (data == nullptr) {
      status = U_MEMORY_ALLOCATION_ERROR;
  }
  return data;
1174}

1176/**
* A class that find the replacement values of locale fields by using AliasData.
*/
1179class AliasReplacer {
1180public:
  AliasReplacer(UErrorCode& status) :
          language(nullptr), script(nullptr), region(nullptr),
          extensions(nullptr),
          // store value in variants only once
          variants(nullptr,
                   ([](UElement e1, UElement e2) -> UBool {
                     return 0==uprv_strcmp((const char*)e1.pointer,:: strcmp((const char*)e1.pointer, (const char*)e2.pointer)
                                           (const char*)e2.pointer):: strcmp((const char*)e1.pointer, (const char*)e2.pointer);}),
                   status),
          data(nullptr) {
  }
  ~AliasReplacer() {
  }

  // Check the fields inside locale, if need to replace fields,
  // place the replaced locale ID in out and return true.
  // Otherwise return false for no replacement or error.
  bool replace(
      const Locale& locale, CharString& out, UErrorCode& status);

1201private:
  const char* language;
  const char* script;
  const char* region;
  const char* extensions;
  UVector variants;

  const AliasData* data;

  inline bool notEmpty(const char* str) {
      return str && str[0] != NULL_CHAR'\0';
  }

  /**
   * If replacement is neither null nor empty and input is either null or empty,
   * return replacement.
   * If replacement is neither null nor empty but input is not empty, return input.
   * If replacement is either null or empty and type is either null or empty,
   * return input.
   * Otherwise return null.
   *   replacement     input      type        return
   *    AAA             nullptr    *           AAA
   *    AAA             BBB        *           BBB
   *    nullptr || ""   CCC        nullptr     CCC
   *    nullptr || ""   *          DDD         nullptr
   */
  inline const char* deleteOrReplace(
          const char* input, const char* type, const char* replacement) {
      return notEmpty(replacement) ?
          ((input == nullptr) ?  replacement : input) :
          ((type == nullptr) ? input  : nullptr);
  }

  inline bool same(const char* a, const char* b) {
      if (a == nullptr && b == nullptr) {
          return true;
      }
      if ((a == nullptr && b != nullptr) ||
          (a != nullptr && b == nullptr)) {
        return false;
      }
      return uprv_strcmp(a, b):: strcmp(a, b) == 0;
  }

  // Gather fields and generate locale ID into out.
  CharString& outputToString(CharString& out, UErrorCode& status);

  // Generate the lookup key.
  CharString& generateKey(const char* language, const char* region,
                          const char* variant, CharString& out,
                          UErrorCode& status);

  void parseLanguageReplacement(const char* replacement,
                                const char*& replaceLanguage,
                                const char*& replaceScript,
                                const char*& replaceRegion,
                                const char*& replaceVariant,
                                const char*& replaceExtensions,
                                UVector& toBeFreed,
                                UErrorCode& status);

  // Replace by using languageAlias.
  bool replaceLanguage(bool checkLanguage, bool checkRegion,
                       bool checkVariants, UVector& toBeFreed,
                       UErrorCode& status);

  // Replace by using territoryAlias.
  bool replaceTerritory(UVector& toBeFreed, UErrorCode& status);

  // Replace by using scriptAlias.
  bool replaceScript(UErrorCode& status);

  // Replace by using variantAlias.
  bool replaceVariant(UErrorCode& status);

  // Replace by using subdivisionAlias.
  bool replaceSubdivision(StringPiece subdivision,
                          CharString& output, UErrorCode& status);

  // Replace transformed extensions.
  bool replaceTransformedExtensions(
      CharString& transformedExtensions, CharString& output, UErrorCode& status);
1283};

1285CharString&
1286AliasReplacer::generateKey(
      const char* language, const char* region, const char* variant,
      CharString& out, UErrorCode& status)
1289{
  if (U_FAILURE(status)) { return out; }
  out.append(language, status);
  if (notEmpty(region)) {
      out.append(SEP_CHAR'_', status)
          .append(region, status);
  }
  if (notEmpty(variant)) {
     out.append(SEP_CHAR'_', status)
         .append(variant, status);
  }
  return out;
1301}

1303void
1304AliasReplacer::parseLanguageReplacement(
  const char* replacement,
  const char*& replacedLanguage,
  const char*& replacedScript,
  const char*& replacedRegion,
  const char*& replacedVariant,
  const char*& replacedExtensions,
  UVector& toBeFreed,
  UErrorCode& status)
1313{
  if (U_FAILURE(status)) {
      return;
  }
  replacedScript = replacedRegion = replacedVariant
      = replacedExtensions = nullptr;
  if (uprv_strchr(replacement, '_'):: strchr(replacement, '_') == nullptr) {
      replacedLanguage = replacement;
      // reach the end, just return it.
      return;
  }
  // We have multiple field so we have to allocate and parse
  CharString* str =
      new CharString(replacement, static_cast<int32_t>(uprv_strlen(replacement):: strlen(replacement)), status);
  LocalPointer<CharString> lpStr(str, status);
  toBeFreed.adoptElement(lpStr.orphan(), status);
  if (U_FAILURE(status)) {
      return;
  }
  char* data = str->data();
  replacedLanguage = (const char*) data;
  char* endOfField = uprv_strchr(data, '_'):: strchr(data, '_');
  *endOfField = '\0'; // null terminiate it.
  endOfField++;
  const char* start = endOfField;
  endOfField = const_cast<char*>(uprv_strchr(start, '_'):: strchr(start, '_'));
  size_t len = 0;
  if (endOfField == nullptr) {
      len = uprv_strlen(start):: strlen(start);
  } else {
      len = endOfField - start;
      *endOfField = '\0'; // null terminiate it.
  }
  if (len == 4 && uprv_isASCIILetter(*start)) {
      // Got a script
      replacedScript = start;
      if (endOfField == nullptr) {
          return;
      }
      start = endOfField++;
      endOfField = const_cast<char*>(uprv_strchr(start, '_'):: strchr(start, '_'));
      if (endOfField == nullptr) {
          len = uprv_strlen(start):: strlen(start);
      } else {
          len = endOfField - start;
          *endOfField = '\0'; // null terminiate it.
      }
  }
  if (len >= 2 && len <= 3) {
      // Got a region
      replacedRegion = start;
      if (endOfField == nullptr) {
          return;
      }
      start = endOfField++;
      endOfField = const_cast<char*>(uprv_strchr(start, '_'):: strchr(start, '_'));
      if (endOfField == nullptr) {
          len = uprv_strlen(start):: strlen(start);
      } else {
          len = endOfField - start;
          *endOfField = '\0'; // null terminiate it.
      }
  }
  if (len >= 4) {
      // Got a variant
      replacedVariant = start;
      if (endOfField == nullptr) {
          return;
      }
      start = endOfField++;
  }
  replacedExtensions = start;
1385}

1387bool
1388AliasReplacer::replaceLanguage(
      bool checkLanguage, bool checkRegion,
      bool checkVariants, UVector& toBeFreed, UErrorCode& status)
1391{
  if (U_FAILURE(status)) {
      return false;
  }
  if (    (checkRegion && region == nullptr) ||
          (checkVariants && variants.size() == 0)) {
      // Nothing to search.
      return false;
  }
  int32_t variant_size = checkVariants ? variants.size() : 1;
  // Since we may have more than one variant, we need to loop through them.
  const char* searchLanguage = checkLanguage ? language : "und";
  const char* searchRegion = checkRegion ? region : nullptr;
  const char* searchVariant = nullptr;
  for (int32_t variant_index = 0;
          variant_index < variant_size;
          variant_index++) {
      if (checkVariants) {
          U_ASSERT(variant_index < variant_size)(static_cast <bool> (variant_index < variant_size) ?
 void (0) : __assert_fail ("variant_index < variant_size",
 __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
          searchVariant = static_cast<const char*>(variants.elementAt(variant_index));
      }

      if (searchVariant != nullptr && uprv_strlen(searchVariant):: strlen(searchVariant) < 4) {
          // Do not consider  ill-formed variant subtag.
          searchVariant = nullptr;
      }
      CharString typeKey;
      generateKey(searchLanguage, searchRegion, searchVariant, typeKey,
                  status);
      if (U_FAILURE(status)) {
          return false;
      }
      const char *replacement = data->languageMap().get(typeKey.data());
      if (replacement == nullptr) {
          // Found no replacement data.
          continue;
      }

      const char* replacedLanguage = nullptr;
      const char* replacedScript = nullptr;
      const char* replacedRegion = nullptr;
      const char* replacedVariant = nullptr;
      const char* replacedExtensions = nullptr;
      parseLanguageReplacement(replacement,
                               replacedLanguage,
                               replacedScript,
                               replacedRegion,
                               replacedVariant,
                               replacedExtensions,
                               toBeFreed,
                               status);
      replacedLanguage =
          (replacedLanguage != nullptr && uprv_strcmp(replacedLanguage, "und"):: strcmp(replacedLanguage, "und") == 0) ?
          language : replacedLanguage;
      replacedScript = deleteOrReplace(script, nullptr, replacedScript);
      replacedRegion = deleteOrReplace(region, searchRegion, replacedRegion);
      replacedVariant = deleteOrReplace(
          searchVariant, searchVariant, replacedVariant);

      if (    same(language, replacedLanguage) &&
              same(script, replacedScript) &&
              same(region, replacedRegion) &&
              same(searchVariant, replacedVariant) &&
              replacedExtensions == nullptr) {
          // Replacement produce no changes.
          continue;
      }

      language = replacedLanguage;
      region = replacedRegion;
      script = replacedScript;
      if (searchVariant != nullptr) {
          if (notEmpty(replacedVariant)) {
              variants.setElementAt((void*)replacedVariant, variant_index);
          } else {
              variants.removeElementAt(variant_index);
          }
      }
      if (replacedExtensions != nullptr) {
          // DO NOTHING
          // UTS35 does not specify what should we do if we have extensions in the
          // replacement. Currently we know only the following 4 "BCP47 LegacyRules" have
          // extensions in them languageAlias:
          //  i_default => en_x_i_default
          //  i_enochian => und_x_i_enochian
          //  i_mingo => see_x_i_mingo
          //  zh_min => nan_x_zh_min
          // But all of them are already changed by code inside ultag_parse() before
          // hitting this code.
      }

      // Something changed by language alias data.
      return true;
  }
  // Nothing changed by language alias data.
  return false;
1487}

1489bool
1490AliasReplacer::replaceTerritory(UVector& toBeFreed, UErrorCode& status)
1491{
  if (U_FAILURE(status)) {
      return false;
  }
  if (region == nullptr) {
      // No region to search.
      return false;
  }
  const char *replacement = data->territoryMap().get(region);
  if (replacement == nullptr) {
      // Found no replacement data for this region.
      return false;
  }
  const char* replacedRegion = replacement;
  const char* firstSpace = uprv_strchr(replacement, ' '):: strchr(replacement, ' ');
  if (firstSpace != nullptr) {
      // If there are are more than one region in the replacement.
      // We need to check which one match based on the language.
      // Cannot use nullptr for language because that will construct
      // the default locale, in that case, use "und" to get the correct
      // locale.
      Locale l = LocaleBuilder()
          .setLanguage(language == nullptr ? "und" : language)
          .setScript(script)
          .build(status);
      l.addLikelySubtags(status);
      const char* likelyRegion = l.getCountry();
      LocalPointer<CharString> item;
      if (likelyRegion != nullptr && uprv_strlen(likelyRegion):: strlen(likelyRegion) > 0) {
          size_t len = uprv_strlen(likelyRegion):: strlen(likelyRegion);
          const char* foundInReplacement = uprv_strstr(replacement,:: strstr(replacement, likelyRegion)
                                                       likelyRegion):: strstr(replacement, likelyRegion);
          if (foundInReplacement != nullptr) {
              // Assuming the case there are no three letter region code in
              // the replacement of territoryAlias
              U_ASSERT(foundInReplacement == replacement ||(static_cast <bool> (foundInReplacement == replacement ||
 *(foundInReplacement-1) == ' ') ? void (0) : __assert_fail (
"foundInReplacement == replacement || *(foundInReplacement-1) == ' '"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
                       *(foundInReplacement-1) == ' ')(static_cast <bool> (foundInReplacement == replacement ||
 *(foundInReplacement-1) == ' ') ? void (0) : __assert_fail (
"foundInReplacement == replacement || *(foundInReplacement-1) == ' '"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
              U_ASSERT(foundInReplacement[len] == ' ' ||(static_cast <bool> (foundInReplacement[len] == ' ' || foundInReplacement
[len] == '\0') ? void (0) : __assert_fail ("foundInReplacement[len] == ' ' || foundInReplacement[len] == '\\0'"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
                       foundInReplacement[len] == '\0')(static_cast <bool> (foundInReplacement[len] == ' ' || foundInReplacement
[len] == '\0') ? void (0) : __assert_fail ("foundInReplacement[len] == ' ' || foundInReplacement[len] == '\\0'"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
              item.adoptInsteadAndCheckErrorCode(
                  new CharString(foundInReplacement, static_cast<int32_t>(len), status), status);
          }
      }
      if (item.isNull() && U_SUCCESS(status)) {
          item.adoptInsteadAndCheckErrorCode(
              new CharString(replacement,
                             static_cast<int32_t>(firstSpace - replacement), status), status);
      }
      if (U_FAILURE(status)) { return false; }
      replacedRegion = item->data();
      toBeFreed.adoptElement(item.orphan(), status);
      if (U_FAILURE(status)) { return false; }
  }
  U_ASSERT(!same(region, replacedRegion))(static_cast <bool> (!same(region, replacedRegion)) ? void
 (0) : __assert_fail ("!same(region, replacedRegion)", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
  region = replacedRegion;
  // The region is changed by data in territory alias.
  return true;
1548}

1550bool
1551AliasReplacer::replaceScript(UErrorCode& status)
1552{
  if (U_FAILURE(status)) {
      return false;
  }
  if (script == nullptr) {
      // No script to search.
      return false;
  }
  const char *replacement = data->scriptMap().get(script);
  if (replacement == nullptr) {
      // Found no replacement data for this script.
      return false;
  }
  U_ASSERT(!same(script, replacement))(static_cast <bool> (!same(script, replacement)) ? void
 (0) : __assert_fail ("!same(script, replacement)", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
  script = replacement;
  // The script is changed by data in script alias.
  return true;
1569}

1571bool
1572AliasReplacer::replaceVariant(UErrorCode& status)
1573{
  if (U_FAILURE(status)) {
      return false;
  }
  // Since we may have more than one variant, we need to loop through them.
  for (int32_t i = 0; i < variants.size(); i++) {
      const char* variant = static_cast<const char*>(variants.elementAt(i));
      const char *replacement = data->variantMap().get(variant);
      if (replacement == nullptr) {
          // Found no replacement data for this variant.
          continue;
      }
      U_ASSERT((uprv_strlen(replacement) >= 5  &&(static_cast <bool> ((:: strlen(replacement) >= 5 &&
 :: strlen(replacement) <= 8) || (:: strlen(replacement) ==
&& replacement[0] >= '0' && replacement
[0] <= '9')) ? void (0) : __assert_fail ("(:: strlen(replacement) >= 5 && :: strlen(replacement) <= 8) || (:: strlen(replacement) == 4 && replacement[0] >= '0' && replacement[0] <= '9')"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
                uprv_strlen(replacement) <= 8) ||(static_cast <bool> ((:: strlen(replacement) >= 5 &&
 :: strlen(replacement) <= 8) || (:: strlen(replacement) ==
&& replacement[0] >= '0' && replacement
[0] <= '9')) ? void (0) : __assert_fail ("(:: strlen(replacement) >= 5 && :: strlen(replacement) <= 8) || (:: strlen(replacement) == 4 && replacement[0] >= '0' && replacement[0] <= '9')"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
               (uprv_strlen(replacement) == 4 &&(static_cast <bool> ((:: strlen(replacement) >= 5 &&
 :: strlen(replacement) <= 8) || (:: strlen(replacement) ==
&& replacement[0] >= '0' && replacement
[0] <= '9')) ? void (0) : __assert_fail ("(:: strlen(replacement) >= 5 && :: strlen(replacement) <= 8) || (:: strlen(replacement) == 4 && replacement[0] >= '0' && replacement[0] <= '9')"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
                replacement[0] >= '0' &&(static_cast <bool> ((:: strlen(replacement) >= 5 &&
 :: strlen(replacement) <= 8) || (:: strlen(replacement) ==
&& replacement[0] >= '0' && replacement
[0] <= '9')) ? void (0) : __assert_fail ("(:: strlen(replacement) >= 5 && :: strlen(replacement) <= 8) || (:: strlen(replacement) == 4 && replacement[0] >= '0' && replacement[0] <= '9')"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
))
                replacement[0] <= '9'))(static_cast <bool> ((:: strlen(replacement) >= 5 &&
 :: strlen(replacement) <= 8) || (:: strlen(replacement) ==
&& replacement[0] >= '0' && replacement
[0] <= '9')) ? void (0) : __assert_fail ("(:: strlen(replacement) >= 5 && :: strlen(replacement) <= 8) || (:: strlen(replacement) == 4 && replacement[0] >= '0' && replacement[0] <= '9')"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
      if (!same(variant, replacement)) {
          variants.setElementAt((void*)replacement, i);
          // Special hack to handle hepburn-heploc => alalc97
          if (uprv_strcmp(variant, "heploc"):: strcmp(variant, "heploc") == 0) {
              for (int32_t j = 0; j < variants.size(); j++) {
                   if (uprv_strcmp((const char*)(variants.elementAt(j)),:: strcmp((const char*)(variants.elementAt(j)), "hepburn")
                                   "hepburn"):: strcmp((const char*)(variants.elementAt(j)), "hepburn") == 0) {
                       variants.removeElementAt(j);
                   }
              }
          }
          return true;
      }
  }
  return false;
1605}

1607bool
1608AliasReplacer::replaceSubdivision(
  StringPiece subdivision, CharString& output, UErrorCode& status)
1610{
  if (U_FAILURE(status)) {
      return false;
  }
  const char *replacement = data->subdivisionMap().get(subdivision.data());
  if (replacement != nullptr) {
      const char* firstSpace = uprv_strchr(replacement, ' '):: strchr(replacement, ' ');
      // Found replacement data for this subdivision.
      size_t len = (firstSpace != nullptr) ?
          (firstSpace - replacement) : uprv_strlen(replacement):: strlen(replacement);
      if (2 <= len && len <= 8) {
          output.append(replacement, static_cast<int32_t>(len), status);
          if (2 == len) {
              // Add 'zzzz' based on changes to UTS #35 for CLDR-14312.
              output.append("zzzz", 4, status);
          }
      }
      return true;
  }
  return false;
1630}

1632bool
1633AliasReplacer::replaceTransformedExtensions(
  CharString& transformedExtensions, CharString& output, UErrorCode& status)
1635{
  // The content of the transformedExtensions will be modified in this
  // function to NUL-terminating (tkey-tvalue) pairs.
  if (U_FAILURE(status)) {
      return false;
  }
  int32_t len = transformedExtensions.length();
  const char* str = transformedExtensions.data();
  const char* tkey = ultag_getTKeyStart(str);
  int32_t tlangLen = (tkey == str) ? 0 :
      ((tkey == nullptr) ? len : static_cast<int32_t>((tkey - str - 1)));
  if (tlangLen > 0) {
      Locale tlang = LocaleBuilder()
          .setLanguageTag(StringPiece(str, tlangLen))
          .build(status);
      tlang.canonicalize(status);
      output = tlang.toLanguageTag<CharString>(status);
      if (U_FAILURE(status)) {
          return false;
      }
      T_CString_toLowerCase(output.data());
  }
  if (tkey != nullptr) {
      // We need to sort the tfields by tkey
      UVector tfields(status);
      if (U_FAILURE(status)) {
          return false;
      }
      do {
          const char* tvalue = uprv_strchr(tkey, '-'):: strchr(tkey, '-');
          if (tvalue == nullptr) {
              status = U_ILLEGAL_ARGUMENT_ERROR;
              return false;
          }
          const char* nextTKey = ultag_getTKeyStart(tvalue);
          if (nextTKey != nullptr) {
              *const_cast<char*>(nextTKey - 1) = '\0'; // NUL terminate tvalue
          }
          tfields.insertElementAt((void*)tkey, tfields.size(), status);
          if (U_FAILURE(status)) {
              return false;
          }
          tkey = nextTKey;
      } while (tkey != nullptr);
      tfields.sort([](UElement e1, UElement e2) -> int32_t {
          return uprv_strcmp((const char*)e1.pointer, (const char*)e2.pointer):: strcmp((const char*)e1.pointer, (const char*)e2.pointer);
      }, status);
      for (int32_t i = 0; i < tfields.size(); i++) {
           if (output.length() > 0) {
               output.append('-', status);
           }
           const char* tfield = static_cast<const char*>(tfields.elementAt(i));
           const char* tvalue = uprv_strchr(tfield, '-'):: strchr(tfield, '-');
           if (tvalue == nullptr) {
               status = U_ILLEGAL_ARGUMENT_ERROR;
               return false;
           }
           // Split the "tkey-tvalue" pair string so that we can canonicalize the tvalue.
           *const_cast<char*>(tvalue++) = '\0'; // NUL terminate tkey
           output.append(tfield, status).append('-', status);
           std::optional<std::string_view> bcpTValue = ulocimp_toBcpType(tfield, tvalue);
           output.append(bcpTValue.has_value() ? *bcpTValue : tvalue, status);
      }
  }
  if (U_FAILURE(status)) {
      return false;
  }
  return true;
1703}

1705CharString&
1706AliasReplacer::outputToString(
  CharString& out, UErrorCode& status)
1708{
  if (U_FAILURE(status)) { return out; }
  out.append(language, status);
  if (notEmpty(script)) {
      out.append(SEP_CHAR'_', status)
          .append(script, status);
  }
  if (notEmpty(region)) {
      out.append(SEP_CHAR'_', status)
          .append(region, status);
  }
  if (variants.size() > 0) {
      if (!notEmpty(script) && !notEmpty(region)) {
        out.append(SEP_CHAR'_', status);
      }
      variants.sort([](UElement e1, UElement e2) -> int32_t {
          return uprv_strcmp((const char*)e1.pointer, (const char*)e2.pointer):: strcmp((const char*)e1.pointer, (const char*)e2.pointer);
      }, status);
      int32_t variantsStart = out.length();
      for (int32_t i = 0; i < variants.size(); i++) {
           out.append(SEP_CHAR'_', status)
               .append(static_cast<const char*>(variants.elementAt(i)),
                       status);
      }
      T_CString_toUpperCase(out.data() + variantsStart);
  }
  if (notEmpty(extensions)) {
      CharString tmp("und_", status);
      tmp.append(extensions, status);
      Locale tmpLocale(tmp.data());
      // only support x extension inside CLDR for now.
      U_ASSERT(extensions[0] == 'x')(static_cast <bool> (extensions[0] == 'x') ? void (0) :
 __assert_fail ("extensions[0] == 'x'", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__));
      out.append(tmpLocale.getName() + 1, status);
  }
  return out;
1743}

1745bool
1746AliasReplacer::replace(const Locale& locale, CharString& out, UErrorCode& status)
1747{
  data = AliasData::singleton(status);
  if (U_FAILURE(status)) {
      return false;
  }
  U_ASSERT(data != nullptr)(static_cast <bool> (data != nullptr) ? void (0) : __assert_fail
 ("data != nullptr", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
  out.clear();
  language = locale.getLanguage();
  if (!notEmpty(language)) {
      language = nullptr;
  }
  script = locale.getScript();
  if (!notEmpty(script)) {
      script = nullptr;
  }
  region = locale.getCountry();
  if (!notEmpty(region)) {
      region = nullptr;
  }
  const char* variantsStr = locale.getVariant();
  CharString variantsBuff(variantsStr, -1, status);
  if (!variantsBuff.isEmpty()) {
      if (U_FAILURE(status)) { return false; }
      char* start = variantsBuff.data();
      T_CString_toLowerCase(start);
      char* end;
      while ((end = uprv_strchr(start, SEP_CHAR):: strchr(start, '_')) != nullptr &&
             U_SUCCESS(status)) {
          *end = NULL_CHAR'\0';  // null terminate inside variantsBuff
          // do not add "" or duplicate data to variants
          if (*start && !variants.contains(start)) {
              variants.addElement(start, status);
          }
          start = end + 1;
      }
      // do not add "" or duplicate data to variants
      if (*start && !variants.contains(start)) {
          variants.addElement(start, status);
      }
  }
  if (U_FAILURE(status)) { return false; }

  // Sort the variants
  variants.sort([](UElement e1, UElement e2) -> int32_t {
      return uprv_strcmp((const char*)e1.pointer, (const char*)e2.pointer):: strcmp((const char*)e1.pointer, (const char*)e2.pointer);
  }, status);

  // A changed count to assert when loop too many times.
  int changed = 0;
  // A UVector to to hold CharString allocated by the replace* method
  // and freed when out of scope from his function.
  UVector stringsToBeFreed([](void *obj) { delete static_cast<CharString*>(obj); },
                           nullptr, 10, status);
  while (U_SUCCESS(status)) {
      // Something wrong with the data cause looping here more than 10 times
      // already.
      U_ASSERT(changed < 5)(static_cast <bool> (changed < 5) ? void (0) : __assert_fail
 ("changed < 5", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
      // From observation of key in data/misc/metadata.txt
      // we know currently we only need to search in the following combination
      // of fields for type in languageAlias:
      // * lang_region_variant
      // * lang_region
      // * lang_variant
      // * lang
      // * und_variant
      // This assumption is ensured by the U_ASSERT in readLanguageAlias
      //
      //                      lang  REGION variant
      if (    replaceLanguage(true, true,  true,  stringsToBeFreed, status) ||
              replaceLanguage(true, true,  false, stringsToBeFreed, status) ||
              replaceLanguage(true, false, true,  stringsToBeFreed, status) ||
              replaceLanguage(true, false, false, stringsToBeFreed, status) ||
              replaceLanguage(false,false, true,  stringsToBeFreed, status) ||
              replaceTerritory(stringsToBeFreed, status) ||
              replaceScript(status) ||
              replaceVariant(status)) {
          // Some values in data is changed, try to match from the beginning
          // again.
          changed++;
          continue;
      }
      // Nothing changed. Break out.
      break;
  }  // while(1)

  if (U_FAILURE(status)) { return false; }
  // Nothing changed and we know the order of the variants are not change
  // because we have no variant or only one.
  const char* extensionsStr = locale_getKeywordsStart(locale.getName());
  if (changed == 0 && variants.size() <= 1 && extensionsStr == nullptr) {
      return false;
  }
  outputToString(out, status);
  if (U_FAILURE(status)) {
      return false;
  }
  if (extensionsStr != nullptr) {
      changed = 0;
      Locale temp(locale);
      LocalPointer<icu::StringEnumeration> iter(locale.createKeywords(status));
      if (U_SUCCESS(status) && !iter.isNull()) {
          const char* key;
          while ((key = iter->next(nullptr, status)) != nullptr) {
              if (uprv_strcmp("sd", key):: strcmp("sd", key) == 0 || uprv_strcmp("rg", key):: strcmp("rg", key) == 0 ||
                      uprv_strcmp("t", key):: strcmp("t", key) == 0) {
                  auto value = locale.getKeywordValue<CharString>(key, status);
                  if (U_FAILURE(status)) {
                      status = U_ZERO_ERROR;
                      continue;
                  }
                  CharString replacement;
                  if (uprv_strlen(key):: strlen(key) == 2) {
                      if (replaceSubdivision(value.toStringPiece(), replacement, status)) {
                          changed++;
                          temp.setKeywordValue(key, replacement.data(), status);
                      }
                  } else {
                      U_ASSERT(uprv_strcmp(key, "t") == 0)(static_cast <bool> (:: strcmp(key, "t") == 0) ? void (
0) : __assert_fail (":: strcmp(key, \"t\") == 0", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
                      if (replaceTransformedExtensions(value, replacement, status)) {
                          changed++;
                          temp.setKeywordValue(key, replacement.data(), status);
                      }
                  }
                  if (U_FAILURE(status)) {
                      return false;
                  }
              }
          }
      }
      if (changed != 0) {
          extensionsStr = locale_getKeywordsStart(temp.getName());
      }
      out.append(extensionsStr, status);
  }
  if (U_FAILURE(status)) {
      return false;
  }
  // If the tag is not changed, return.
  if (uprv_strcmp(out.data(), locale.getName()):: strcmp(out.data(), locale.getName()) == 0) {
      out.clear();
      return false;
  }
  return true;
1890}

1892// Return true if the locale is changed during canonicalization.
1893// The replaced value then will be put into out.
1894bool
1895canonicalizeLocale(const Locale& locale, CharString& out, UErrorCode& status)
1896{
  if (U_FAILURE(status)) { return false; }
  AliasReplacer replacer(status);
  return replacer.replace(locale, out, status);
1900}

1902// Function to optimize for known cases without so we can skip the loading
1903// of resources in the startup time until we really need it.
1904bool
1905isKnownCanonicalizedLocale(const char* locale, UErrorCode& status)
1906{
  if (U_FAILURE(status)) { return false; }

  if (    uprv_strcmp(locale, "c"):: strcmp(locale, "c") == 0 ||
          uprv_strcmp(locale, "en"):: strcmp(locale, "en") == 0 ||
          uprv_strcmp(locale, "en_US"):: strcmp(locale, "en_US") == 0) {
      return true;
  }

  // common well-known Canonicalized.
  umtx_initOnce(gKnownCanonicalizedInitOnce,
                &loadKnownCanonicalized, status);
  if (U_FAILURE(status)) {
      return false;
  }
  U_ASSERT(gKnownCanonicalized != nullptr)(static_cast <bool> (gKnownCanonicalized != nullptr) ? void
 (0) : __assert_fail ("gKnownCanonicalized != nullptr", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
  return uhash_geti(gKnownCanonicalized, locale) != 0;
1923}

1925}  // namespace

1927U_NAMESPACE_END}

1929// Function for testing.
1930U_EXPORT const char* const*
1931ulocimp_getKnownCanonicalizedLocaleForTest(int32_t& length)
1932{
  U_NAMESPACE_USEusing namespace icu_78;
  length = UPRV_LENGTHOF(KNOWN_CANONICALIZED)(int32_t)(sizeof(KNOWN_CANONICALIZED)/sizeof((KNOWN_CANONICALIZED
)[0]));
  return KNOWN_CANONICALIZED;
1936}

1938// Function for testing.
1939U_EXPORT bool
1940ulocimp_isCanonicalizedLocaleForTest(const char* localeName)
1941{
  U_NAMESPACE_USEusing namespace icu_78;
  Locale l(localeName);
  UErrorCode status = U_ZERO_ERROR;
  CharString temp;
  return !canonicalizeLocale(l, temp, status) && U_SUCCESS(status);
1947}

1949U_NAMESPACE_BEGINnamespace icu_78 {

1951Locale& Locale::init(const char* localeID, UBool canonicalize)
1952{
  return localeID == nullptr ? *this = getDefault() : init(StringPiece{localeID}, canonicalize);
1954}

1956/*This function initializes a Locale from a C locale ID*/
1957Locale& Locale::init(StringPiece localeID, UBool canonicalize)
1958{
  /* Free our current storage */
  Nest& nest = payload.emplace<Nest>();

  // not a loop:
  // just an easy way to have a common error-exit
  // without goto and without another function
  do {
      char *separator;
      char *field[5] = {nullptr};
      int32_t fieldLen[5] = {0};
      int32_t fieldIdx;
      int32_t variantField;
      int32_t length;
      UErrorCode err;

      const auto parse = [canonicalize](std::string_view localeID,
                                        char* name,
                                        int32_t nameCapacity,
                                        UErrorCode& status) {
          return ByteSinkUtil::viaByteSinkToTerminatedChars(
              name, nameCapacity,
              [&](ByteSink& sink, UErrorCode& status) {
                  if (canonicalize) {
                      ulocimp_canonicalize(localeID, sink, status);
                  } else {
                      ulocimp_getName(localeID, sink, status);
                  }
              },
              status);
      };

      // "canonicalize" the locale ID to ICU/Java format
      char* fullName = nest.baseName;
      err = U_ZERO_ERROR;
      length = parse(localeID, fullName, sizeof Nest::baseName, err);

      FixedString fullNameBuffer;
      if (err == U_BUFFER_OVERFLOW_ERROR || length >= static_cast<int32_t>(sizeof Nest::baseName)) {
          /*Go to heap for the fullName if necessary*/
          if (!fullNameBuffer.reserve(length + 1)) {
              break; // error: out of memory
          }
          fullName = fullNameBuffer.getAlias();
          err = U_ZERO_ERROR;
          length = parse(localeID, fullName, length + 1, err);
      }
      if(U_FAILURE(err) || err == U_STRING_NOT_TERMINATED_WARNING) {
          /* should never occur */
          break;
      }

      std::string_view language;
      std::string_view script;
      std::string_view region;
      int32_t variantBegin = length;

      /* after uloc_getName/canonicalize() we know that only '_' are separators */
      /* But _ could also appeared in timezone such as "en@timezone=America/Los_Angeles" */
      separator = field[0] = fullName;
      fieldIdx = 1;
      char* at = uprv_strchr(fullName, '@'):: strchr(fullName, '@');
      while ((separator = uprv_strchr(field[fieldIdx-1], SEP_CHAR):: strchr(field[fieldIdx-1], '_')) != nullptr &&
             fieldIdx < UPRV_LENGTHOF(field)(int32_t)(sizeof(field)/sizeof((field)[0]))-1 &&
             (at == nullptr || separator < at)) {
          field[fieldIdx] = separator + 1;
          fieldLen[fieldIdx - 1] = static_cast<int32_t>(separator - field[fieldIdx - 1]);
          fieldIdx++;
      }
      // variant may contain @foo or .foo POSIX cruft; remove it
      separator = uprv_strchr(field[fieldIdx-1], '@'):: strchr(field[fieldIdx-1], '@');
      char* sep2 = uprv_strchr(field[fieldIdx-1], '.'):: strchr(field[fieldIdx-1], '.');
      if (separator!=nullptr || sep2!=nullptr) {
          if (separator==nullptr || (sep2!=nullptr && separator > sep2)) {
              separator = sep2;
          }
          fieldLen[fieldIdx - 1] = static_cast<int32_t>(separator - field[fieldIdx - 1]);
      } else {
          fieldLen[fieldIdx - 1] = length - static_cast<int32_t>(field[fieldIdx - 1] - fullName);
      }
      bool hasKeywords = at != nullptr && uprv_strchr(at + 1, '='):: strchr(at + 1, '=') != nullptr;

      if (fieldLen[0] >= ULOC_LANG_CAPACITY12)
      {
          break; // error: the language field is too long
      }

      variantField = 1; /* Usually the 2nd one, except when a script or country is also used. */
      if (fieldLen[0] > 0) {
          /* We have a language */
          language = {fullName, static_cast<std::string_view::size_type>(fieldLen[0])};
      }
      if (fieldLen[1] == 4 && uprv_isASCIILetter(field[1][0]) &&
              uprv_isASCIILetter(field[1][1]) && uprv_isASCIILetter(field[1][2]) &&
              uprv_isASCIILetter(field[1][3])) {
          /* We have at least a script */
          script = {field[1], static_cast<std::string_view::size_type>(fieldLen[1])};
          variantField++;
      }

      if (fieldLen[variantField] == 2 || fieldLen[variantField] == 3) {
          /* We have a country */
          region = {field[variantField], static_cast<std::string_view::size_type>(fieldLen[variantField])};
          variantField++;
      } else if (fieldLen[variantField] == 0) {
          variantField++; /* script or country empty but variant in next field (i.e. en__POSIX) */
      }

      if (fieldLen[variantField] > 0) {
          /* We have a variant */
          variantBegin = static_cast<int32_t>(field[variantField] - fullName);
      } else if (hasKeywords) {
          // The original computation of variantBegin leaves it equal to the length
          // of fullName if there is no variant.  It should instead be
          // the length of the baseName.
          variantBegin = static_cast<int32_t>(at - fullName);
      }

      if (!hasKeywords && Nest::fits(length, language, script, region)) {
          U_ASSERT(fullName == nest.baseName)(static_cast <bool> (fullName == nest.baseName) ? void (
0) : __assert_fail ("fullName == nest.baseName", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
          U_ASSERT(fullNameBuffer.isEmpty())(static_cast <bool> (fullNameBuffer.isEmpty()) ? void (
0) : __assert_fail ("fullNameBuffer.isEmpty()", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
          nest.init(language, script, region, variantBegin);
      } else {
          if (fullName == nest.baseName) {
              U_ASSERT(fullNameBuffer.isEmpty())(static_cast <bool> (fullNameBuffer.isEmpty()) ? void (
0) : __assert_fail ("fullNameBuffer.isEmpty()", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
              fullNameBuffer = {fullName, static_cast<std::string_view::size_type>(length)};
              if (fullNameBuffer.isEmpty()) {
                  break; // error: out of memory
              }
              if (!language.empty()) {
                  language = {fullNameBuffer.data(), language.size()};
              }
              if (!script.empty()) {
                  script = {fullNameBuffer.data() + (script.data() - fullName), script.size()};
              }
              if (!region.empty()) {
                  region = {fullNameBuffer.data() + (region.data() - fullName), region.size()};
              }
          }
          Heap& heap = payload.emplace<Heap>(language, script, region, variantBegin);
          if (isBogus()) {
              break; // error: out of memory
          }
          U_ASSERT(!fullNameBuffer.isEmpty())(static_cast <bool> (!fullNameBuffer.isEmpty()) ? void (
0) : __assert_fail ("!fullNameBuffer.isEmpty()", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__));
          heap.ptr->fullName = std::move(fullNameBuffer);
          if (hasKeywords) {
              if (std::string_view::size_type baseNameLength = at - fullName; baseNameLength > 0) {
                  heap.ptr->baseName = {heap.ptr->fullName.data(), baseNameLength};
                  if (heap.ptr->baseName.isEmpty()) {
                      break; // error: out of memory
                  }
              }
          }
      }

      if (canonicalize) {
          if (!isKnownCanonicalizedLocale(getName(), err)) {
              CharString replaced;
              // Not sure it is already canonicalized
              if (canonicalizeLocale(*this, replaced, err)) {
                  U_ASSERT(U_SUCCESS(err))(static_cast <bool> (U_SUCCESS(err)) ? void (0) : __assert_fail
 ("U_SUCCESS(err)", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
                  // If need replacement, call init again.
                  init(replaced.data(), false);
              }
              if (U_FAILURE(err)) {
                  break;
              }
          }
      }   // if (canonicalize) {

      // successful end of init()
      return *this;
  } while(0); /*loop doesn't iterate*/

  // when an error occurs, then set this object to "bogus" (there is no UErrorCode here)
  setToBogus();

  return *this;
2136}

2138int32_t
2139Locale::hashCode() const
2140{
  return ustr_hashCharsN(getName(), static_cast<int32_t>(uprv_strlen(getName()):: strlen(getName())));
2142}

2144void
2145Locale::setToBogus() {
  /* Free our current storage */
  payload.setToBogus();
2148}

2150const Locale& U_EXPORT2
2151Locale::getDefault()
2152{
  {
      Mutex lock(&gDefaultLocaleMutex);
      if (gDefaultLocale != nullptr) {
          return *gDefaultLocale;
      }
  }
  UErrorCode status = U_ZERO_ERROR;
  return *locale_set_default_internal(nullptr, status);
2161}



2165void U_EXPORT2
2166Locale::setDefault( const   Locale&     newLocale,
                          UErrorCode&  status)
2168{
  if (U_FAILURE(status)) {
      return;
  }

  /* Set the default from the full name string of the supplied locale.
   * This is a convenient way to access the default locale caching mechanisms.
   */
  const char *localeID = newLocale.getName();
  locale_set_default_internal(localeID, status);
2178}

2180void
2181Locale::addLikelySubtags(UErrorCode& status) {
  if (U_FAILURE(status)) {
      return;
  }

  CharString maximizedLocaleID = ulocimp_addLikelySubtags(getName(), status);

  if (U_FAILURE(status)) {
      if (status == U_MEMORY_ALLOCATION_ERROR) {
          setToBogus();
      }
      return;
  }

  init(maximizedLocaleID.data(), /*canonicalize=*/false);
  if (isBogus()) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
  }
2199}

2201void
2202Locale::minimizeSubtags(UErrorCode& status) {
  Locale::minimizeSubtags(false, status);
2204}
2205void
2206Locale::minimizeSubtags(bool favorScript, UErrorCode& status) {
  if (U_FAILURE(status)) {
      return;
  }

  CharString minimizedLocaleID = ulocimp_minimizeSubtags(getName(), favorScript, status);

  if (U_FAILURE(status)) {
      if (status == U_MEMORY_ALLOCATION_ERROR) {
          setToBogus();
      }
      return;
  }

  init(minimizedLocaleID.data(), /*canonicalize=*/false);
  if (isBogus()) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
  }
2224}

2226void
2227Locale::canonicalize(UErrorCode& status) {
  if (U_FAILURE(status)) {
      return;
  }
  if (isBogus()) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  CharString uncanonicalized(getName(), status);
  if (U_FAILURE(status)) {
      if (status == U_MEMORY_ALLOCATION_ERROR) {
          setToBogus();
      }
      return;
  }
  init(uncanonicalized.data(), /*canonicalize=*/true);
  if (isBogus()) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
  }
2246}

2248Locale U_EXPORT2
2249Locale::forLanguageTag(StringPiece tag, UErrorCode& status)
2250{
  Locale result(Locale::eBOGUS);

  if (U_FAILURE(status)) {
      return result;
  }

  // If a BCP 47 language tag is passed as the language parameter to the
  // normal Locale constructor, it will actually fall back to invoking
  // uloc_forLanguageTag() to parse it if it somehow is able to detect that
  // the string actually is BCP 47. This works well for things like strings
  // using BCP 47 extensions, but it does not at all work for things like
  // legacy language tags (marked as “Type: grandfathered” in BCP 47,
  // e.g., "en-GB-oed") which are possible to also
  // interpret as ICU locale IDs and because of that won't trigger the BCP 47
  // parsing. Therefore the code here explicitly calls uloc_forLanguageTag()
  // and then Locale::init(), instead of just calling the normal constructor.

  int32_t parsedLength;
  CharString localeID = ulocimp_forLanguageTag(
          tag.data(),
          tag.length(),
          &parsedLength,
          status);

  if (U_FAILURE(status)) {
      return result;
  }

  if (parsedLength != tag.size()) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return result;
  }

  result.init(localeID.data(), /*canonicalize=*/false);
  if (result.isBogus()) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
  }
  return result;
2289}

2291void
2292Locale::toLanguageTag(ByteSink& sink, UErrorCode& status) const
2293{
  if (U_FAILURE(status)) {
      return;
  }

  if (isBogus()) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  ulocimp_toLanguageTag(getName(), sink, /*strict=*/false, status);
2304}

2306Locale U_EXPORT2
2307Locale::createFromName (const char *name)
2308{
  if (name) {
      Locale l("");
      l.init(name, false);
      return l;
  }
  else {
      return getDefault();
  }
2317}

2319Locale U_EXPORT2
2320Locale::createFromName(StringPiece name) {
  Locale loc("");
  loc.init(name, false);
  return loc;
2324}

2326Locale U_EXPORT2
2327Locale::createCanonical(const char* name) {
  Locale loc("");
  loc.init(name, true);
  return loc;
2331}

2333const char *
2334Locale::getISO3Language() const
2335{
  return uloc_getISO3Language(getName());
2337}


2340const char *
2341Locale::getISO3Country() const
2342{
  return uloc_getISO3Country(getName());
2344}

2346/**
* Return the LCID value as specified in the "LocaleID" resource for this
* locale.  The LocaleID must be expressed as a hexadecimal number, from
* one to four digits.  If the LocaleID resource is not present, or is
* in an incorrect format, 0 is returned.  The LocaleID is for use in
* Windows (it is an LCID), but is available on all platforms.
*/
2353uint32_t
2354Locale::getLCID() const
2355{
  return uloc_getLCID(getName());
2357}

2359const char* const* U_EXPORT2 Locale::getISOCountries()
2360{
  return uloc_getISOCountries();
2362}

2364const char* const* U_EXPORT2 Locale::getISOLanguages()
2365{
  return uloc_getISOLanguages();
2367}

2369// Set the locale's data based on a posix id.
2370void Locale::setFromPOSIXID(const char *posixID)
2371{
  init(posixID, true);
2373}

2375const Locale & U_EXPORT2
2376Locale::getRoot()
2377{
  return getLocale(eROOT);
2379}

2381const Locale & U_EXPORT2
2382Locale::getEnglish()
2383{
  return getLocale(eENGLISH);
2385}

2387const Locale & U_EXPORT2
2388Locale::getFrench()
2389{
  return getLocale(eFRENCH);
2391}

2393const Locale & U_EXPORT2
2394Locale::getGerman()
2395{
  return getLocale(eGERMAN);
2397}

2399const Locale & U_EXPORT2
2400Locale::getItalian()
2401{
  return getLocale(eITALIAN);
2403}

2405const Locale & U_EXPORT2
2406Locale::getJapanese()
2407{
  return getLocale(eJAPANESE);
2409}

2411const Locale & U_EXPORT2
2412Locale::getKorean()
2413{
  return getLocale(eKOREAN);
2415}

2417const Locale & U_EXPORT2
2418Locale::getChinese()
2419{
  return getLocale(eCHINESE);
2421}

2423const Locale & U_EXPORT2
2424Locale::getSimplifiedChinese()
2425{
  return getLocale(eCHINA);
2427}

2429const Locale & U_EXPORT2
2430Locale::getTraditionalChinese()
2431{
  return getLocale(eTAIWAN);
2433}


2436const Locale & U_EXPORT2
2437Locale::getFrance()
2438{
  return getLocale(eFRANCE);
2440}

2442const Locale & U_EXPORT2
2443Locale::getGermany()
2444{
  return getLocale(eGERMANY);
2446}

2448const Locale & U_EXPORT2
2449Locale::getItaly()
2450{
  return getLocale(eITALY);
2452}

2454const Locale & U_EXPORT2
2455Locale::getJapan()
2456{
  return getLocale(eJAPAN);
2458}

2460const Locale & U_EXPORT2
2461Locale::getKorea()
2462{
  return getLocale(eKOREA);
2464}

2466const Locale & U_EXPORT2
2467Locale::getChina()
2468{
  return getLocale(eCHINA);
2470}

2472const Locale & U_EXPORT2
2473Locale::getPRC()
2474{
  return getLocale(eCHINA);
2476}

2478const Locale & U_EXPORT2
2479Locale::getTaiwan()
2480{
  return getLocale(eTAIWAN);
2482}

2484const Locale & U_EXPORT2
2485Locale::getUK()
2486{
  return getLocale(eUK);
2488}

2490const Locale & U_EXPORT2
2491Locale::getUS()
2492{
  return getLocale(eUS);
2494}

2496const Locale & U_EXPORT2
2497Locale::getCanada()
2498{
  return getLocale(eCANADA);
2500}

2502const Locale & U_EXPORT2
2503Locale::getCanadaFrench()
2504{
  return getLocale(eCANADA_FRENCH);
2506}

2508const Locale &
2509Locale::getLocale(int locid)
2510{
  Locale *localeCache = getLocaleCache();
  U_ASSERT((locid < eMAX_LOCALES)&&(locid>=0))(static_cast <bool> ((locid < eMAX_LOCALES)&&
(locid>=0)) ? void (0) : __assert_fail ("(locid < eMAX_LOCALES)&&(locid>=0)"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
  if (localeCache == nullptr) {
      // Failure allocating the locale cache.
      //   The best we can do is return a nullptr reference.
      locid = 0;
  }
  return localeCache[locid]; /*operating on nullptr*/
2519}

2521/*
2522This function is defined this way in order to get around static
2523initialization and static destruction.
*/
2525Locale *
2526Locale::getLocaleCache()
2527{
  UErrorCode status = U_ZERO_ERROR;
  umtx_initOnce(gLocaleCacheInitOnce, locale_init, status);
  return gLocaleCache;
2531}

2533class KeywordEnumeration : public StringEnumeration {
2534protected:
  FixedString keywords;
2536private:
  int32_t length;
  const char *current;
  static const char fgClassID;

2541public:
  static UClassID U_EXPORT2 getStaticClassID() { return (UClassID)&fgClassID; }
  virtual UClassID getDynamicClassID() const override { return getStaticClassID(); }
2544public:
  KeywordEnumeration(const char *keys, int32_t keywordLen, int32_t currentIndex, UErrorCode &status)
      : keywords(), length(keywordLen), current(nullptr) {
      if(U_SUCCESS(status) && keywordLen != 0) {
          if(keys == nullptr || keywordLen < 0) {
              status = U_ILLEGAL_ARGUMENT_ERROR;
          } else {
              keywords = {keys, static_cast<std::string_view::size_type>(length)};
              if (keywords.isEmpty()) {
                  status = U_MEMORY_ALLOCATION_ERROR;
              } else {
                  current = keywords.data() + currentIndex;
              }
          }
      }
  }

  virtual ~KeywordEnumeration();

  virtual StringEnumeration * clone() const override
  {
      UErrorCode status = U_ZERO_ERROR;
      return new KeywordEnumeration(
              keywords.data(), length,
              static_cast<int32_t>(current - keywords.data()), status);
  }

  virtual int32_t count(UErrorCode& status) const override {
      if (U_FAILURE(status)) { return 0; }
      const char *kw = keywords.data();
      int32_t result = 0;
      while(*kw) {
          result++;
          kw += uprv_strlen(kw):: strlen(kw)+1;
      }
      return result;
  }

  virtual const char* next(int32_t* resultLength, UErrorCode& status) override {
      const char* result;
      int32_t len;
      if(U_SUCCESS(status) && *current != 0) {
          result = current;
          len = static_cast<int32_t>(uprv_strlen(current):: strlen(current));
          current += len+1;
          if(resultLength != nullptr) {
              *resultLength = len;
          }
      } else {
          if(resultLength != nullptr) {
              *resultLength = 0;
          }
          result = nullptr;
      }
      return result;
  }

  virtual const UnicodeString* snext(UErrorCode& status) override {
      if (U_FAILURE(status)) { return nullptr; }
      int32_t resultLength = 0;
      const char *s = next(&resultLength, status);
      return setChars(s, resultLength, status);
  }

  virtual void reset(UErrorCode& status) override {
      if (U_FAILURE(status)) { return; }
      current = keywords.data();
  }
2612};

2614const char KeywordEnumeration::fgClassID = '\0';

2616// Out-of-line virtual destructor to serve as the "key function".
2617KeywordEnumeration::~KeywordEnumeration() = default;

2619// A wrapper around KeywordEnumeration that calls uloc_toUnicodeLocaleKey() in
2620// the next() method for each keyword before returning it.
2621class UnicodeKeywordEnumeration : public KeywordEnumeration {
2622public:
  using KeywordEnumeration::KeywordEnumeration;
  virtual ~UnicodeKeywordEnumeration();

  virtual const char* next(int32_t* resultLength, UErrorCode& status) override {
      const char* legacy_key = KeywordEnumeration::next(nullptr, status);
      while (U_SUCCESS(status) && legacy_key != nullptr) {
          const char* key = uloc_toUnicodeLocaleKey(legacy_key);
          if (key != nullptr) {
              if (resultLength != nullptr) {
                  *resultLength = static_cast<int32_t>(uprv_strlen(key):: strlen(key));
              }
              return key;
          }
          // Not a Unicode keyword, could be a t, x or other, continue to look at the next one.
          legacy_key = KeywordEnumeration::next(nullptr, status);
      }
      if (resultLength != nullptr) *resultLength = 0;
      return nullptr;
  }
  virtual int32_t count(UErrorCode& status) const override {
      if (U_FAILURE(status)) { return 0; }
      const char *kw = keywords.data();
      int32_t result = 0;
      while(*kw) {
          if (uloc_toUnicodeLocaleKey(kw) != nullptr) {
              result++;
          }
          kw += uprv_strlen(kw):: strlen(kw)+1;
      }
      return result;
  }
2654};

2656// Out-of-line virtual destructor to serve as the "key function".
2657UnicodeKeywordEnumeration::~UnicodeKeywordEnumeration() = default;

2659StringEnumeration *
2660Locale::createKeywords(UErrorCode &status) const
2661{
  StringEnumeration *result = nullptr;

  if (U_FAILURE(status)) {
      return result;
  }

  const char* variantStart = uprv_strchr(getName(), '@'):: strchr(getName(), '@');
  const char* assignment = uprv_strchr(getName(), '='):: strchr(getName(), '=');
  if(variantStart) {
      if(assignment > variantStart) {
          CharString keywords = ulocimp_getKeywords(variantStart + 1, '@', false, status);
          if (U_SUCCESS(status) && !keywords.isEmpty()) {
              result = new KeywordEnumeration(keywords.data(), keywords.length(), 0, status);
              if (!result) {
                  status = U_MEMORY_ALLOCATION_ERROR;
              }
          }
      } else {
          status = U_INVALID_FORMAT_ERROR;
      }
  }
  return result;
2684}

2686StringEnumeration *
2687Locale::createUnicodeKeywords(UErrorCode &status) const
2688{
  StringEnumeration *result = nullptr;

  if (U_FAILURE(status)) {
      return result;
  }

  const char* variantStart = uprv_strchr(getName(), '@'):: strchr(getName(), '@');
  const char* assignment = uprv_strchr(getName(), '='):: strchr(getName(), '=');
  if(variantStart) {
      if(assignment > variantStart) {
          CharString keywords = ulocimp_getKeywords(variantStart + 1, '@', false, status);
          if (U_SUCCESS(status) && !keywords.isEmpty()) {
              result = new UnicodeKeywordEnumeration(keywords.data(), keywords.length(), 0, status);
              if (!result) {
                  status = U_MEMORY_ALLOCATION_ERROR;
              }
          }
      } else {
          status = U_INVALID_FORMAT_ERROR;
      }
  }
  return result;
2711}

2713int32_t
2714Locale::getKeywordValue(const char* keywordName, char *buffer, int32_t bufLen, UErrorCode &status) const
2715{
  return uloc_getKeywordValue(getName(), keywordName, buffer, bufLen, &status);
2717}

2719void
2720Locale::getKeywordValue(StringPiece keywordName, ByteSink& sink, UErrorCode& status) const {
  if (U_FAILURE(status)) {
      return;
  }

  if (isBogus()) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  ulocimp_getKeywordValue(getName(), keywordName, sink, status);
2731}

2733void
2734Locale::getUnicodeKeywordValue(StringPiece keywordName,
                             ByteSink& sink,
                             UErrorCode& status) const {
  if (U_FAILURE(status)) {
      return;
  }

  std::optional<std::string_view> legacy_key = ulocimp_toLegacyKeyWithFallback(keywordName);
  if (!legacy_key.has_value()) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  auto legacy_value = getKeywordValue<CharString>(*legacy_key, status);

  if (U_FAILURE(status)) {
      return;
  }

  std::optional<std::string_view> unicode_value =
      ulocimp_toBcpTypeWithFallback(keywordName, legacy_value.toStringPiece());
  if (!unicode_value.has_value()) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  sink.Append(unicode_value->data(), static_cast<int32_t>(unicode_value->size()));
2761}

2763void
2764Locale::setKeywordValue(StringPiece keywordName,
                      StringPiece keywordValue,
                      UErrorCode& status) {
  if (U_FAILURE(status)) { return; }
  if (keywordName.empty()) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }
  if (status == U_STRING_NOT_TERMINATED_WARNING) {
      status = U_ZERO_ERROR;
  }

  CharString localeID(getName(), -1, status);
  ulocimp_setKeywordValue(keywordName, keywordValue, localeID, status);
  if (U_FAILURE(status)) {
      if (status == U_MEMORY_ALLOCATION_ERROR) {
          setToBogus();
      }
      return;
  }

  const char* at = locale_getKeywordsStart(localeID.toStringPiece());
  bool hasKeywords = at != nullptr && uprv_strchr(at + 1, '='):: strchr(at + 1, '=') != nullptr;

  Nest* nest = payload.get<Nest>();
  if (!hasKeywords) {
      if (nest == nullptr) {
          // There are no longer any keywords left, so it might now be
          // possible to move the payload from Heap to Nest.
          Heap* heap = payload.get<Heap>();
          U_ASSERT(heap != nullptr)(static_cast <bool> (heap != nullptr) ? void (0) : __assert_fail
 ("heap != nullptr", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
          if (Nest::fits(localeID.length(), heap->language, heap->script, heap->region)) {
              int32_t variantBegin = heap->ptr->variantBegin;
              U_ASSERT(variantBegin >= 0)(static_cast <bool> (variantBegin >= 0) ? void (0) :
 __assert_fail ("variantBegin >= 0", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__));
              U_ASSERT(static_cast<size_t>(variantBegin) < sizeof Nest::baseName)(static_cast <bool> (static_cast<size_t>(variantBegin
) < sizeof Nest::baseName) ? void (0) : __assert_fail ("static_cast<size_t>(variantBegin) < sizeof Nest::baseName"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
));
              nest = &payload.emplace<Nest>(std::move(*heap), static_cast<uint8_t>(variantBegin));
              localeID.extract(nest->baseName, sizeof Nest::baseName, status);
          } else {
              heap->ptr->baseName.clear();
              heap->ptr->fullName = localeID.toStringPiece();
              if (heap->ptr->fullName.isEmpty()) {
                  status = U_MEMORY_ALLOCATION_ERROR;
                  setToBogus();
                  return;
              }
          }
      }
  } else {
      Heap* heap = nullptr;
      if (nest != nullptr) {
          // A keyword has been added, so the payload now needs to be moved
          // from Nest to Heap so that it can get a baseName.
          Nest copy(*nest);
          heap = &payload.emplace<Heap>(copy.language,
                                        copy.script,
                                        copy.region,
                                        copy.variantBegin);
          if (isBogus()) {
              status = U_MEMORY_ALLOCATION_ERROR;
              return;
          }
      } else {
          heap = payload.get<Heap>();
      }
      U_ASSERT(heap != nullptr)(static_cast <bool> (heap != nullptr) ? void (0) : __assert_fail
 ("heap != nullptr", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__));
      heap->ptr->fullName = localeID.toStringPiece();
      if (heap->ptr->fullName.isEmpty()) {
          status = U_MEMORY_ALLOCATION_ERROR;
          setToBogus();
          return;
      }

      if (heap->ptr->baseName.isEmpty()) {
          // Has added the first keyword, meaning that the fullName is no longer also the baseName.
          if (std::string_view::size_type baseNameLength = at - localeID.data(); baseNameLength > 0) {
              heap->ptr->baseName = {heap->ptr->fullName.data(), baseNameLength};
              if (heap->ptr->baseName.isEmpty()) {
                  status = U_MEMORY_ALLOCATION_ERROR;
                  setToBogus();
                  return;
              }
          }
      }
  }
2848}

2850void
2851Locale::setUnicodeKeywordValue(StringPiece keywordName,
                             StringPiece keywordValue,
                             UErrorCode& status) {
  if (U_FAILURE(status)) {
      return;
  }

  std::optional<std::string_view> legacy_key = ulocimp_toLegacyKeyWithFallback(keywordName);
  if (!legacy_key.has_value()) {
      status = U_ILLEGAL_ARGUMENT_ERROR;
      return;
  }

  std::string_view value;

  if (!keywordValue.empty()) {
      std::optional<std::string_view> legacy_value =
          ulocimp_toLegacyTypeWithFallback(keywordName, keywordValue);
      if (!legacy_value.has_value()) {
          status = U_ILLEGAL_ARGUMENT_ERROR;
          return;
      }
      value = *legacy_value;
  }

  setKeywordValue(*legacy_key, value, status);
2877}

2879const char*
2880Locale::getCountry() const {
  return getField<&Nest::getRegion, &Heap::getRegion>();
2882}

2884const char*
2885Locale::getLanguage() const {
  return getField<&Nest::getLanguage, &Heap::getLanguage>();
2887}

2889const char*
2890Locale::getScript() const {
  return getField<&Nest::getScript, &Heap::getScript>();
2892}

2894const char*
2895Locale::getVariant() const {
  return getField<&Nest::getVariant, &Heap::getVariant>();
2897}

2899const char*
2900Locale::getName() const {
  return getField<&Nest::getBaseName, &Heap::getFullName>();
2902}

2904const char*
2905Locale::getBaseName() const {
  return getField<&Nest::getBaseName, &Heap::getBaseName>();
2907}

2909template <const char* (Locale::Nest::*const NEST)() const,
        const char* (Locale::Heap::*const HEAP)() const>
2911const char* Locale::getField() const {
  return payload.visit([] { return ""; },
                       [](const Nest& nest) { return (nest.*NEST)(); },
                       [](const Heap& heap) { return (heap.*HEAP)(); });
2915}

2917Locale::Iterator::~Iterator() = default;

2919//eof
2920U_NAMESPACE_END}

←

/root/firefox-clang/intl/icu/source/common/cmemory.h

→

1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4******************************************************************************
5*
6*   Copyright (C) 1997-2016, International Business Machines
7*   Corporation and others.  All Rights Reserved.
8*
9******************************************************************************
10*
11* File CMEMORY.H
12*
13*  Contains stdlib.h/string.h memory functions
14*
15* @author       Bertrand A. Damiba
16*
17* Modification History:
18*
19*   Date        Name        Description
20*   6/20/98     Bertrand    Created.
21*  05/03/99     stephen     Changed from functions to macros.
22*
23******************************************************************************
24*/

26#ifndef CMEMORY_H
27#define CMEMORY_H

29#include "unicode/utypes.h"

31#include <stddef.h>
32#include <string.h>
33#include "unicode/localpointer.h"
34#include "uassert.h"

36#if U_DEBUG1 && defined(UPRV_MALLOC_COUNT)
37#include <stdio.h>
38#endif

40// uprv_memcpy and uprv_memmove
41#if defined(__clang__1)
42#define uprv_memcpy(dst, src, size)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (src != __null
) ? void (0) : __assert_fail ("src != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memcpy(dst, src, size); } while (false) UPRV_BLOCK_MACRO_BEGINdo { \
  /* Suppress warnings about addresses that will never be NULL */ \
  _Pragma("clang diagnostic push")clang diagnostic push
 \
  _Pragma("clang diagnostic ignored \"-Waddress\"")clang diagnostic ignored "-Waddress"
 \
  U_ASSERT(dst != NULL)(static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  U_ASSERT(src != NULL)(static_cast <bool> (src != __null) ? void (0) : __assert_fail
 ("src != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  _Pragma("clang diagnostic pop")clang diagnostic pop
 \
  U_STANDARD_CPP_NAMESPACE:: memcpy(dst, src, size); \
50} UPRV_BLOCK_MACRO_ENDwhile (false)
51#define uprv_memmove(dst, src, size)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (src != __null
) ? void (0) : __assert_fail ("src != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memmove(dst, src, size); } while (false) UPRV_BLOCK_MACRO_BEGINdo { \
  /* Suppress warnings about addresses that will never be NULL */ \
  _Pragma("clang diagnostic push")clang diagnostic push
 \
  _Pragma("clang diagnostic ignored \"-Waddress\"")clang diagnostic ignored "-Waddress"
 \
  U_ASSERT(dst != NULL)(static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  U_ASSERT(src != NULL)(static_cast <bool> (src != __null) ? void (0) : __assert_fail
 ("src != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  _Pragma("clang diagnostic pop")clang diagnostic pop
 \
  U_STANDARD_CPP_NAMESPACE:: memmove(dst, src, size); \
59} UPRV_BLOCK_MACRO_ENDwhile (false)
60#elif defined(__GNUC__4)
61#define uprv_memcpy(dst, src, size)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (src != __null
) ? void (0) : __assert_fail ("src != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memcpy(dst, src, size); } while (false) UPRV_BLOCK_MACRO_BEGINdo { \
  /* Suppress warnings about addresses that will never be NULL */ \
  _Pragma("GCC diagnostic push")GCC diagnostic push
 \
  _Pragma("GCC diagnostic ignored \"-Waddress\"")GCC diagnostic ignored "-Waddress"
 \
  U_ASSERT(dst != NULL)(static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  U_ASSERT(src != NULL)(static_cast <bool> (src != __null) ? void (0) : __assert_fail
 ("src != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  _Pragma("GCC diagnostic pop")GCC diagnostic pop
 \
  U_STANDARD_CPP_NAMESPACE:: memcpy(dst, src, size); \
69} UPRV_BLOCK_MACRO_ENDwhile (false)
70#define uprv_memmove(dst, src, size)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (src != __null
) ? void (0) : __assert_fail ("src != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memmove(dst, src, size); } while (false) UPRV_BLOCK_MACRO_BEGINdo { \
  /* Suppress warnings about addresses that will never be NULL */ \
  _Pragma("GCC diagnostic push")GCC diagnostic push
 \
  _Pragma("GCC diagnostic ignored \"-Waddress\"")GCC diagnostic ignored "-Waddress"
 \
  U_ASSERT(dst != NULL)(static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  U_ASSERT(src != NULL)(static_cast <bool> (src != __null) ? void (0) : __assert_fail
 ("src != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  _Pragma("GCC diagnostic pop")GCC diagnostic pop
 \
  U_STANDARD_CPP_NAMESPACE:: memmove(dst, src, size); \
78} UPRV_BLOCK_MACRO_ENDwhile (false)
79#else
80#define uprv_memcpy(dst, src, size)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (src != __null
) ? void (0) : __assert_fail ("src != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memcpy(dst, src, size); } while (false) UPRV_BLOCK_MACRO_BEGINdo { \
  U_ASSERT(dst != NULL)(static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  U_ASSERT(src != NULL)(static_cast <bool> (src != __null) ? void (0) : __assert_fail
 ("src != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  U_STANDARD_CPP_NAMESPACE:: memcpy(dst, src, size); \
84} UPRV_BLOCK_MACRO_ENDwhile (false)
85#define uprv_memmove(dst, src, size)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (src != __null
) ? void (0) : __assert_fail ("src != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memmove(dst, src, size); } while (false) UPRV_BLOCK_MACRO_BEGINdo { \
  U_ASSERT(dst != NULL)(static_cast <bool> (dst != __null) ? void (0) : __assert_fail
 ("dst != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  U_ASSERT(src != NULL)(static_cast <bool> (src != __null) ? void (0) : __assert_fail
 ("src != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); \
  U_STANDARD_CPP_NAMESPACE:: memmove(dst, src, size); \
89} UPRV_BLOCK_MACRO_ENDwhile (false)
90#endif

92/**
* \def UPRV_LENGTHOF
* Convenience macro to determine the length of a fixed array at compile-time.
* @param array A fixed length array
* @return The length of the array, in elements
* @internal
*/
99#define UPRV_LENGTHOF(array)(int32_t)(sizeof(array)/sizeof((array)[0])) (int32_t)(sizeof(array)/sizeof((array)[0]))
100#define uprv_memset(buffer, mark, size):: memset(buffer, mark, size) U_STANDARD_CPP_NAMESPACE:: memset(buffer, mark, size)
101#define uprv_memcmp(buffer1, buffer2, size):: memcmp(buffer1, buffer2,size) U_STANDARD_CPP_NAMESPACE:: memcmp(buffer1, buffer2,size)
102#define uprv_memchr(ptr, value, num):: memchr(ptr, value, num) U_STANDARD_CPP_NAMESPACE:: memchr(ptr, value, num)

104U_CAPIextern "C" void * U_EXPORT2
105uprv_malloc(size_t s) U_MALLOC_ATTR__attribute__ ((__malloc__)) U_ALLOC_SIZE_ATTR(1)__attribute__ ((alloc_size(1)));

107U_CAPIextern "C" void * U_EXPORT2
108uprv_realloc(void *mem, size_t size) U_ALLOC_SIZE_ATTR(2)__attribute__ ((alloc_size(2)));

110U_CAPIextern "C" void U_EXPORT2
111uprv_free(void *mem);

113U_CAPIextern "C" void * U_EXPORT2
114uprv_calloc(size_t num, size_t size) U_MALLOC_ATTR__attribute__ ((__malloc__)) U_ALLOC_SIZE_ATTR2(1,2)__attribute__ ((alloc_size(1,2)));

116/**
* Get the least significant bits of a pointer (a memory address).
* For example, with a mask of 3, the macro gets the 2 least significant bits,
* which will be 0 if the pointer is 32-bit (4-byte) aligned.
*
* uintptr_t is the most appropriate integer type to cast to.
*/
123#define U_POINTER_MASK_LSB(ptr, mask)((uintptr_t)(ptr) & (mask)) ((uintptr_t)(ptr) & (mask))

125/**
* Create & return an instance of "type" in statically allocated storage.
* e.g.
*    static std::mutex *myMutex = STATIC_NEW(std::mutex);
* To destroy an object created in this way, invoke the destructor explicitly, e.g.
*    myMutex->~mutex();
* DO NOT use delete.
* DO NOT use with class UMutex, which has specific support for static instances.
*
* STATIC_NEW is intended for use when
*   - We want a static (or global) object.
*   - We don't want it to ever be destructed, or to explicitly control destruction,
*     to avoid use-after-destruction problems.
*   - We want to avoid an ordinary heap allocated object,
*     to avoid the possibility of memory allocation failures, and
*     to avoid memory leak reports, from valgrind, for example.
* This is defined as a macro rather than a template function because each invocation
* must define distinct static storage for the object being returned.
*/
144#define STATIC_NEW(type)[] () { alignas(type) static char storage[sizeof(type)]; return
 new(storage) type();} () [] () { \
  alignas(type) static char storage[sizeof(type)]; \
  return new(storage) type();} ()

148/**
*  Heap clean up function, called from u_cleanup()
*    Clears any user heap functions from u_setMemoryFunctions()
*    Does NOT deallocate any remaining allocated memory.
*/
153U_CFUNCextern "C" UBool 
154cmemory_cleanup(void);

156/**
* A function called by <TT>uhash_remove</TT>,
* <TT>uhash_close</TT>, or <TT>uhash_put</TT> to delete
* an existing key or value.
* @param obj A key or value stored in a hashtable
* @see uprv_deleteUObject
*/
163typedef void U_CALLCONV UObjectDeleter(void* obj);

165/**
* Deleter for UObject instances.
* Works for all subclasses of UObject because it has a virtual destructor.
*/
169U_CAPIextern "C" void U_EXPORT2
170uprv_deleteUObject(void *obj);

172#ifdef __cplusplus202002L

174#include <utility>
175#include "unicode/uobject.h"

177U_NAMESPACE_BEGINnamespace icu_78 {

179/**
* "Smart pointer" class, deletes memory via uprv_free().
* For most methods see the LocalPointerBase base class.
* Adds operator[] for array item access.
*
* @see LocalPointerBase
*/
186template<typename T>
187class LocalMemory : public LocalPointerBase<T> {
188public:
  using LocalPointerBase<T>::operator*;
  using LocalPointerBase<T>::operator->;
  /**
   * Constructor takes ownership.
   * @param p simple pointer to an array of T items that is adopted
   */
  explicit LocalMemory(T *p=nullptr) : LocalPointerBase<T>(p) {}
5
←
Passing null pointer value via 1st parameter 'p'→
6
←
Calling default constructor for 'LocalPointerBase<const char *>'→
8
←
Returning from default constructor for 'LocalPointerBase<const char *>'→
  /**
   * Move constructor, leaves src with isNull().
   * @param src source smart pointer
   */
  LocalMemory(LocalMemory<T> &&src) noexcept : LocalPointerBase<T>(src.ptr) {
      src.ptr=nullptr;
  }
  /**
   * Destructor deletes the memory it owns.
   */
  ~LocalMemory() {
      uprv_free(LocalPointerBase<T>::ptr);
  }
  /**
   * Move assignment operator, leaves src with isNull().
   * The behavior is undefined if *this and src are the same object.
   * @param src source smart pointer
   * @return *this
   */
  LocalMemory<T> &operator=(LocalMemory<T> &&src) noexcept {
      uprv_free(LocalPointerBase<T>::ptr);
      LocalPointerBase<T>::ptr=src.ptr;
      src.ptr=nullptr;
      return *this;
  }
  /**
   * Swap pointers.
   * @param other other smart pointer
   */
  void swap(LocalMemory<T> &other) noexcept {
      T *temp=LocalPointerBase<T>::ptr;
      LocalPointerBase<T>::ptr=other.ptr;
      other.ptr=temp;
  }
  /**
   * Non-member LocalMemory swap function.
   * @param p1 will get p2's pointer
   * @param p2 will get p1's pointer
   */
  friend inline void swap(LocalMemory<T> &p1, LocalMemory<T> &p2) noexcept {
      p1.swap(p2);
  }
  /**
   * Deletes the array it owns,
   * and adopts (takes ownership of) the one passed in.
   * @param p simple pointer to an array of T items that is adopted
   */
  void adoptInstead(T *p) {
      uprv_free(LocalPointerBase<T>::ptr);
      LocalPointerBase<T>::ptr=p;
  }
  /**
   * Deletes the array it owns, allocates a new one and reset its bytes to 0.
   * Returns the new array pointer.
   * If the allocation fails, then the current array is unchanged and
   * this method returns nullptr.
   * @param newCapacity must be >0
   * @return the allocated array pointer, or nullptr if the allocation failed
   */
  inline T *allocateInsteadAndReset(int32_t newCapacity=1);
  /**
   * Deletes the array it owns and allocates a new one, copying length T items.
   * Returns the new array pointer.
   * If the allocation fails, then the current array is unchanged and
   * this method returns nullptr.
   * @param newCapacity must be >0
   * @param length number of T items to be copied from the old array to the new one;
   *               must be no more than the capacity of the old array,
   *               which the caller must track because the LocalMemory does not track it
   * @return the allocated array pointer, or nullptr if the allocation failed
   */
  inline T *allocateInsteadAndCopy(int32_t newCapacity=1, int32_t length=0);
  /**
   * Array item access (writable).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   */
  T &operator[](ptrdiff_t i) const { return LocalPointerBase<T>::ptr[i]; }
21
←
Returning null reference
275};

277template<typename T>
278inline T *LocalMemory<T>::allocateInsteadAndReset(int32_t newCapacity) {
  if(newCapacity>0) {
      T *p=(T *)uprv_malloc(newCapacity*sizeof(T));
      if(p!=nullptr) {
          uprv_memset(p, 0, newCapacity*sizeof(T)):: memset(p, 0, newCapacity*sizeof(T));
          uprv_free(LocalPointerBase<T>::ptr);
          LocalPointerBase<T>::ptr=p;
      }
      return p;
  } else {
      return nullptr;
  }
290}


293template<typename T>
294inline T *LocalMemory<T>::allocateInsteadAndCopy(int32_t newCapacity, int32_t length) {
  if(newCapacity>0) {
      T *p=(T *)uprv_malloc(newCapacity*sizeof(T));
      if(p!=nullptr) {
          if(length>0) {
              if(length>newCapacity) {
                  length=newCapacity;
              }
              uprv_memcpy(p, LocalPointerBase<T>::ptr, (size_t)length*sizeof(T))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (p != __null) ? void (0) : __assert_fail
 ("p != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (LocalPointerBase
<T>::ptr != __null) ? void (0) : __assert_fail ("LocalPointerBase<T>::ptr != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); clang diagnostic pop
 :: memcpy(p, LocalPointerBase<T>
::ptr, (size_t)length*sizeof(T)); } while (false);
          }
          uprv_free(LocalPointerBase<T>::ptr);
          LocalPointerBase<T>::ptr=p;
      }
      return p;
  } else {
      return nullptr;
  }
311}

313/**
* Simple array/buffer management class using uprv_malloc() and uprv_free().
* Provides an internal array with fixed capacity. Can alias another array
* or allocate one.
*
* The array address is properly aligned for type T. It might not be properly
* aligned for types larger than T (or larger than the largest subtype of T).
*
* Unlike LocalMemory and LocalArray, this class never adopts
* (takes ownership of) another array.
*
* WARNING: MaybeStackArray only works with primitive (plain-old data) types.
* It does NOT know how to call a destructor! If you work with classes with
* destructors, consider:
*
* - LocalArray in localpointer.h if you know the length ahead of time
* - MaybeStackVector if you know the length at runtime
*/
331template<typename T, int32_t stackCapacity>
332class MaybeStackArray {
333public:
  // No heap allocation. Use only on the stack.
  static void* U_EXPORT2 operator new(size_t) noexcept = delete;
  static void* U_EXPORT2 operator new[](size_t) noexcept = delete;
  static void* U_EXPORT2 operator new(size_t, void*) noexcept = delete;

  /**
   * Default constructor initializes with internal T[stackCapacity] buffer.
   */
  MaybeStackArray() : ptr(stackArray), capacity(stackCapacity), needToRelease(false) {}
  /**
   * Automatically allocates the heap array if the argument is larger than the stack capacity.
   * Intended for use when an approximate capacity is known at compile time but the true
   * capacity is not known until runtime.
   */
  MaybeStackArray(int32_t newCapacity, UErrorCode status) : MaybeStackArray() {
      if (U_FAILURE(status)) {
          return;
      }
      if (capacity < newCapacity) {
          if (resize(newCapacity) == nullptr) {
              status = U_MEMORY_ALLOCATION_ERROR;
          }
      }
  }
  /**
   * Destructor deletes the array (if owned).
   */
  ~MaybeStackArray() { releaseArray(); }
  /**
   * Move constructor: transfers ownership or copies the stack array.
   */
  MaybeStackArray(MaybeStackArray<T, stackCapacity> &&src) noexcept;
  /**
   * Move assignment: transfers ownership or copies the stack array.
   */
  MaybeStackArray<T, stackCapacity> &operator=(MaybeStackArray<T, stackCapacity> &&src) noexcept;
  /**
   * Returns the array capacity (number of T items).
   * @return array capacity
   */
  int32_t getCapacity() const { return capacity; }
  /**
   * Access without ownership change.
   * @return the array pointer
   */
  T *getAlias() const { return ptr; }
  /**
   * Returns the array limit. Simple convenience method.
   * @return getAlias()+getCapacity()
   */
  T *getArrayLimit() const { return getAlias()+capacity; }
  // No "operator T *() const" because that can make
  // expressions like mbs[index] ambiguous for some compilers.
  /**
   * Array item access (const).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   */
  const T &operator[](ptrdiff_t i) const { return ptr[i]; }
  /**
   * Array item access (writable).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   */
  T &operator[](ptrdiff_t i) { return ptr[i]; }
  /**
   * Deletes the array (if owned) and aliases another one, no transfer of ownership.
   * If the arguments are illegal, then the current array is unchanged.
   * @param otherArray must not be nullptr
   * @param otherCapacity must be >0
   */
  void aliasInstead(T *otherArray, int32_t otherCapacity) {
      if(otherArray!=nullptr && otherCapacity>0) {
          releaseArray();
          ptr=otherArray;
          capacity=otherCapacity;
          needToRelease=false;
      }
  }
  /**
   * Deletes the array (if owned) and allocates a new one, copying length T items.
   * Returns the new array pointer.
   * If the allocation fails, then the current array is unchanged and
   * this method returns nullptr.
   * @param newCapacity can be less than or greater than the current capacity;
   *                    must be >0
   * @param length number of T items to be copied from the old array to the new one
   * @return the allocated array pointer, or nullptr if the allocation failed
   */
  inline T *resize(int32_t newCapacity, int32_t length=0);
  /**
   * Gives up ownership of the array if owned, or else clones it,
   * copying length T items; resets itself to the internal stack array.
   * Returns nullptr if the allocation failed.
   * @param length number of T items to copy when cloning,
   *        and capacity of the clone when cloning
   * @param resultCapacity will be set to the returned array's capacity (output-only)
   * @return the array pointer;
   *         caller becomes responsible for deleting the array
   */
  inline T *orphanOrClone(int32_t length, int32_t &resultCapacity);

438protected:
  // Resizes the array to the size of src, then copies the contents of src.
  void copyFrom(const MaybeStackArray &src, UErrorCode &status) {
      if (U_FAILURE(status)) {
          return;
      }
      if (this->resize(src.capacity, 0) == nullptr) {
          status = U_MEMORY_ALLOCATION_ERROR;
          return;
      }
      uprv_memcpy(this->ptr, src.ptr, (size_t)capacity * sizeof(T))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (this->ptr != __null) ? void (
0) : __assert_fail ("this->ptr != __null", __builtin_FILE (
), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); (static_cast
 <bool> (src.ptr != __null) ? void (0) : __assert_fail (
"src.ptr != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); clang diagnostic pop
 :: memcpy(this->
ptr, src.ptr, (size_t)capacity * sizeof(T)); } while (false);
  }

451private:
  T *ptr;
  int32_t capacity;
  UBool needToRelease;
  T stackArray[stackCapacity];
  void releaseArray() {
      if(needToRelease) {
          uprv_free(ptr);
      }
  }
  void resetToStackArray() {
      ptr=stackArray;
      capacity=stackCapacity;
      needToRelease=false;
  }
  /* No comparison operators with other MaybeStackArray's. */
  bool operator==(const MaybeStackArray & /*other*/) = delete;
  bool operator!=(const MaybeStackArray & /*other*/) = delete;
  /* No ownership transfer: No copy constructor, no assignment operator. */
  MaybeStackArray(const MaybeStackArray & /*other*/) = delete;
  void operator=(const MaybeStackArray & /*other*/) = delete;
472};

474template<typename T, int32_t stackCapacity>
475icu::MaybeStackArray<T, stackCapacity>::MaybeStackArray(
      MaybeStackArray <T, stackCapacity>&& src) noexcept
      : ptr(src.ptr), capacity(src.capacity), needToRelease(src.needToRelease) {
  if (src.ptr == src.stackArray) {
      ptr = stackArray;
      uprv_memcpy(stackArray, src.stackArray, sizeof(T) * src.capacity)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (stackArray != __null) ? void (0)
 : __assert_fail ("stackArray != __null", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__)); (static_cast <bool
> (src.stackArray != __null) ? void (0) : __assert_fail ("src.stackArray != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); clang diagnostic pop
 :: memcpy(stackArray, src.stackArray
, sizeof(T) * src.capacity); } while (false);
  } else {
      src.resetToStackArray();  // take ownership away from src
  }
484}

486template<typename T, int32_t stackCapacity>
487inline MaybeStackArray <T, stackCapacity>&
488MaybeStackArray<T, stackCapacity>::operator=(MaybeStackArray <T, stackCapacity>&& src) noexcept {
  releaseArray();  // in case this instance had its own memory allocated
  capacity = src.capacity;
  needToRelease = src.needToRelease;
  if (src.ptr == src.stackArray) {
      ptr = stackArray;
      uprv_memcpy(stackArray, src.stackArray, sizeof(T) * src.capacity)do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (stackArray != __null) ? void (0)
 : __assert_fail ("stackArray != __null", __builtin_FILE (), __builtin_LINE
 (), __extension__ __PRETTY_FUNCTION__)); (static_cast <bool
> (src.stackArray != __null) ? void (0) : __assert_fail ("src.stackArray != __null"
, __builtin_FILE (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__
)); clang diagnostic pop
 :: memcpy(stackArray, src.stackArray
, sizeof(T) * src.capacity); } while (false);
  } else {
      ptr = src.ptr;
      src.resetToStackArray();  // take ownership away from src
  }
  return *this;
500}

502template<typename T, int32_t stackCapacity>
503inline T *MaybeStackArray<T, stackCapacity>::resize(int32_t newCapacity, int32_t length) {
  if(newCapacity>0) {
505#if U_DEBUG1 && defined(UPRV_MALLOC_COUNT)
      ::fprintf(::stderrstderr, "MaybeStackArray (resize) alloc %d * %lu\n", newCapacity, sizeof(T));
507#endif
      T *p=(T *)uprv_malloc(newCapacity*sizeof(T));
      if(p!=nullptr) {
          if(length>0) {
              if(length>capacity) {
                  length=capacity;
              }
              if(length>newCapacity) {
                  length=newCapacity;
              }
              uprv_memcpy(p, ptr, (size_t)length*sizeof(T))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (p != __null) ? void (0) : __assert_fail
 ("p != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (ptr != __null
) ? void (0) : __assert_fail ("ptr != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memcpy(p, ptr, (size_t)length*sizeof(T));
 } while (false);
          }
          releaseArray();
          ptr=p;
          capacity=newCapacity;
          needToRelease=true;
      }
      return p;
  } else {
      return nullptr;
  }
528}

530template<typename T, int32_t stackCapacity>
531inline T *MaybeStackArray<T, stackCapacity>::orphanOrClone(int32_t length, int32_t &resultCapacity) {
  T *p;
  if(needToRelease) {
      p=ptr;
  } else if(length<=0) {
      return nullptr;
  } else {
      if(length>capacity) {
          length=capacity;
      }
      p=(T *)uprv_malloc(length*sizeof(T));
542#if U_DEBUG1 && defined(UPRV_MALLOC_COUNT)
    ::fprintf(::stderrstderr,"MaybeStacArray (orphan) alloc %d * %lu\n", length,sizeof(T));
544#endif
      if(p==nullptr) {
          return nullptr;
      }
      uprv_memcpy(p, ptr, (size_t)length*sizeof(T))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (p != __null) ? void (0) : __assert_fail
 ("p != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (ptr != __null
) ? void (0) : __assert_fail ("ptr != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memcpy(p, ptr, (size_t)length*sizeof(T));
 } while (false);
  }
  resultCapacity=length;
  resetToStackArray();
  return p;
553}

555/**
* Variant of MaybeStackArray that allocates a header struct and an array
* in one contiguous memory block, using uprv_malloc() and uprv_free().
* Provides internal memory with fixed array capacity. Can alias another memory
* block or allocate one.
* The stackCapacity is the number of T items in the internal memory,
* not counting the H header.
* Unlike LocalMemory and LocalArray, this class never adopts
* (takes ownership of) another memory block.
*/
565template<typename H, typename T, int32_t stackCapacity>
566class MaybeStackHeaderAndArray {
567public:
  // No heap allocation. Use only on the stack.
  static void* U_EXPORT2 operator new(size_t) noexcept = delete;
  static void* U_EXPORT2 operator new[](size_t) noexcept = delete;
  static void* U_EXPORT2 operator new(size_t, void*) noexcept = delete;

  /**
   * Default constructor initializes with internal H+T[stackCapacity] buffer.
   */
  MaybeStackHeaderAndArray() : ptr(&stackHeader), capacity(stackCapacity), needToRelease(false) {}
  /**
   * Destructor deletes the memory (if owned).
   */
  ~MaybeStackHeaderAndArray() { releaseMemory(); }
  /**
   * Returns the array capacity (number of T items).
   * @return array capacity
   */
  int32_t getCapacity() const { return capacity; }
  /**
   * Access without ownership change.
   * @return the header pointer
   */
  H *getAlias() const { return ptr; }
  /**
   * Returns the array start.
   * @return array start, same address as getAlias()+1
   */
  T *getArrayStart() const { return reinterpret_cast<T *>(getAlias()+1); }
  /**
   * Returns the array limit.
   * @return array limit
   */
  T *getArrayLimit() const { return getArrayStart()+capacity; }
  /**
   * Access without ownership change. Same as getAlias().
   * A class instance can be used directly in expressions that take a T *.
   * @return the header pointer
   */
  operator H *() const { return ptr; }
  /**
   * Array item access (writable).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   */
  T &operator[](ptrdiff_t i) { return getArrayStart()[i]; }
  /**
   * Deletes the memory block (if owned) and aliases another one, no transfer of ownership.
   * If the arguments are illegal, then the current memory is unchanged.
   * @param otherArray must not be nullptr
   * @param otherCapacity must be >0
   */
  void aliasInstead(H *otherMemory, int32_t otherCapacity) {
      if(otherMemory!=nullptr && otherCapacity>0) {
          releaseMemory();
          ptr=otherMemory;
          capacity=otherCapacity;
          needToRelease=false;
      }
  }
  /**
   * Deletes the memory block (if owned) and allocates a new one,
   * copying the header and length T array items.
   * Returns the new header pointer.
   * If the allocation fails, then the current memory is unchanged and
   * this method returns nullptr.
   * @param newCapacity can be less than or greater than the current capacity;
   *                    must be >0
   * @param length number of T items to be copied from the old array to the new one
   * @return the allocated pointer, or nullptr if the allocation failed
   */
  inline H *resize(int32_t newCapacity, int32_t length=0);
  /**
   * Gives up ownership of the memory if owned, or else clones it,
   * copying the header and length T array items; resets itself to the internal memory.
   * Returns nullptr if the allocation failed.
   * @param length number of T items to copy when cloning,
   *        and array capacity of the clone when cloning
   * @param resultCapacity will be set to the returned array's capacity (output-only)
   * @return the header pointer;
   *         caller becomes responsible for deleting the array
   */
  inline H *orphanOrClone(int32_t length, int32_t &resultCapacity);
651private:
  H *ptr;
  int32_t capacity;
  UBool needToRelease;
  // stackHeader must precede stackArray immediately.
  H stackHeader;
  T stackArray[stackCapacity];
  void releaseMemory() {
      if(needToRelease) {
          uprv_free(ptr);
      }
  }
  /* No comparison operators with other MaybeStackHeaderAndArray's. */
  bool operator==(const MaybeStackHeaderAndArray & /*other*/) {return false;}
  bool operator!=(const MaybeStackHeaderAndArray & /*other*/) {return true;}
  /* No ownership transfer: No copy constructor, no assignment operator. */
  MaybeStackHeaderAndArray(const MaybeStackHeaderAndArray & /*other*/) {}
  void operator=(const MaybeStackHeaderAndArray & /*other*/) {}
669};

671template<typename H, typename T, int32_t stackCapacity>
672inline H *MaybeStackHeaderAndArray<H, T, stackCapacity>::resize(int32_t newCapacity,
                                                              int32_t length) {
  if(newCapacity>=0) {
675#if U_DEBUG1 && defined(UPRV_MALLOC_COUNT)
    ::fprintf(::stderrstderr,"MaybeStackHeaderAndArray alloc %d + %d * %ul\n", sizeof(H),newCapacity,sizeof(T));
677#endif
      H *p=(H *)uprv_malloc(sizeof(H)+newCapacity*sizeof(T));
      if(p!=nullptr) {
          if(length<0) {
              length=0;
          } else if(length>0) {
              if(length>capacity) {
                  length=capacity;
              }
              if(length>newCapacity) {
                  length=newCapacity;
              }
          }
          uprv_memcpy(p, ptr, sizeof(H)+(size_t)length*sizeof(T))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (p != __null) ? void (0) : __assert_fail
 ("p != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (ptr != __null
) ? void (0) : __assert_fail ("ptr != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memcpy(p, ptr, sizeof(H)+(size_t)length*sizeof
(T)); } while (false);
          releaseMemory();
          ptr=p;
          capacity=newCapacity;
          needToRelease=true;
      }
      return p;
  } else {
      return nullptr;
  }
700}

702template<typename H, typename T, int32_t stackCapacity>
703inline H *MaybeStackHeaderAndArray<H, T, stackCapacity>::orphanOrClone(int32_t length,
                                                                     int32_t &resultCapacity) {
  H *p;
  if(needToRelease) {
      p=ptr;
  } else {
      if(length<0) {
          length=0;
      } else if(length>capacity) {
          length=capacity;
      }
714#if U_DEBUG1 && defined(UPRV_MALLOC_COUNT)
    ::fprintf(::stderrstderr,"MaybeStackHeaderAndArray (orphan) alloc %ul + %d * %lu\n", sizeof(H),length,sizeof(T));
716#endif
      p=(H *)uprv_malloc(sizeof(H)+length*sizeof(T));
      if(p==nullptr) {
          return nullptr;
      }
      uprv_memcpy(p, ptr, sizeof(H)+(size_t)length*sizeof(T))do { clang diagnostic push
 clang diagnostic ignored "-Waddress"

 (static_cast <bool> (p != __null) ? void (0) : __assert_fail
 ("p != __null", __builtin_FILE (), __builtin_LINE (), __extension__
 __PRETTY_FUNCTION__)); (static_cast <bool> (ptr != __null
) ? void (0) : __assert_fail ("ptr != __null", __builtin_FILE
 (), __builtin_LINE (), __extension__ __PRETTY_FUNCTION__)); clang
 diagnostic pop
 :: memcpy(p, ptr, sizeof(H)+(size_t)length*sizeof
(T)); } while (false);
  }
  resultCapacity=length;
  ptr=&stackHeader;
  capacity=stackCapacity;
  needToRelease=false;
  return p;
728}

730/**
* A simple memory management class that creates new heap allocated objects (of
* any class that has a public constructor), keeps track of them and eventually
* deletes them all in its own destructor.
*
* A typical use-case would be code like this:
*
*     MemoryPool<MyType> pool;
*
*     MyType* o1 = pool.create();
*     if (o1 != nullptr) {
*         foo(o1);
*     }
*
*     MyType* o2 = pool.create(1, 2, 3);
*     if (o2 != nullptr) {
*         bar(o2);
*     }
*
*     // MemoryPool will take care of deleting the MyType objects.
*
* It doesn't do anything more than that, and is intentionally kept minimalist.
*/
753template<typename T, int32_t stackCapacity = 8>
754class MemoryPool : public UMemory {
755public:
  MemoryPool() : fCount(0), fPool() {}

  ~MemoryPool() {
      for (int32_t i = 0; i < fCount; ++i) {
          delete fPool[i];
      }
  }

  MemoryPool(const MemoryPool&) = delete;
  MemoryPool& operator=(const MemoryPool&) = delete;

  MemoryPool(MemoryPool&& other) noexcept : fCount(other.fCount),
                                              fPool(std::move(other.fPool)) {
      other.fCount = 0;
  }

  MemoryPool& operator=(MemoryPool&& other) noexcept {
      // Since `this` may contain instances that need to be deleted, we can't
      // just throw them away and replace them with `other`. The normal way of
      // dealing with this in C++ is to swap `this` and `other`, rather than
      // simply overwrite: the destruction of `other` can then take care of
      // running MemoryPool::~MemoryPool() over the still-to-be-deallocated
      // instances.
      std::swap(fCount, other.fCount);
      std::swap(fPool, other.fPool);
      return *this;
  }

  /**
   * Creates a new object of typename T, by forwarding any and all arguments
   * to the typename T constructor.
   *
   * @param args Arguments to be forwarded to the typename T constructor.
   * @return A pointer to the newly created object, or nullptr on error.
   */
  template<typename... Args>
  T* create(Args&&... args) {
      int32_t capacity = fPool.getCapacity();
      if (fCount == capacity &&
          fPool.resize(capacity == stackCapacity ? 4 * capacity : 2 * capacity,
                       capacity) == nullptr) {
          return nullptr;
      }
      return fPool[fCount++] = new T(std::forward<Args>(args)...);
  }

  template <typename... Args>
  T* createAndCheckErrorCode(UErrorCode &status, Args &&... args) {
      if (U_FAILURE(status)) {
          return nullptr;
      }
      T *pointer = this->create(args...);
      if (U_SUCCESS(status) && pointer == nullptr) {
          status = U_MEMORY_ALLOCATION_ERROR;
      }
      return pointer;
  }

  /**
   * @return Number of elements that have been allocated.
   */
  int32_t count() const {
      return fCount;
  }

821protected:
  int32_t fCount;
  MaybeStackArray<T*, stackCapacity> fPool;
824};

826/**
* An internal Vector-like implementation based on MemoryPool.
*
* Heap-allocates each element and stores pointers.
*
* To append an item to the vector, use emplaceBack.
*
*     MaybeStackVector<MyType> vector;
*     MyType* element = vector.emplaceBack();
*     if (!element) {
*         status = U_MEMORY_ALLOCATION_ERROR;
*     }
*     // do stuff with element
*
* To loop over the vector, use a for loop with indices:
*
*     for (int32_t i = 0; i < vector.length(); i++) {
*         MyType* element = vector[i];
*     }
*/
846template<typename T, int32_t stackCapacity = 8>
847class MaybeStackVector : protected MemoryPool<T, stackCapacity> {
848public:
  template<typename... Args>
  T* emplaceBack(Args&&... args) {
      return this->create(args...);
  }

  template <typename... Args>
  T *emplaceBackAndCheckErrorCode(UErrorCode &status, Args &&... args) {
      return this->createAndCheckErrorCode(status, args...);
  }

  int32_t length() const {
      return this->fCount;
  }

  T** getAlias() {
      return this->fPool.getAlias();
  }

  const T *const *getAlias() const {
      return this->fPool.getAlias();
  }

  /**
   * Array item access (read-only).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   */
  const T* operator[](ptrdiff_t i) const {
      return this->fPool[i];
  }

  /**
   * Array item access (writable).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   */
  T* operator[](ptrdiff_t i) {
      return this->fPool[i];
  }
890};


893U_NAMESPACE_END}

895#endif  /* __cplusplus */
896#endif  /* CMEMORY_H */

←

/root/firefox-clang/obj-x86_64-pc-linux-gnu/dist/include/unicode/localpointer.h

1// © 2016 and later: Unicode, Inc. and others.
2// License & terms of use: http://www.unicode.org/copyright.html
3/*
4*******************************************************************************
5*
6*   Copyright (C) 2009-2016, International Business Machines
7*   Corporation and others.  All Rights Reserved.
8*
9*******************************************************************************
10*   file name:  localpointer.h
11*   encoding:   UTF-8
12*   tab size:   8 (not used)
13*   indentation:4
14*
15*   created on: 2009nov13
16*   created by: Markus W. Scherer
17*/

19#ifndef __LOCALPOINTER_H__
20#define __LOCALPOINTER_H__

22/**
* \file
* \brief C++ API: "Smart pointers" for use with and in ICU4C C++ code.
*
* These classes are inspired by
* - std::auto_ptr
* - boost::scoped_ptr & boost::scoped_array
* - Taligent Safe Pointers (TOnlyPointerTo)
*
* but none of those provide for all of the goals for ICU smart pointers:
* - Smart pointer owns the object and releases it when it goes out of scope.
* - No transfer of ownership via copy/assignment to reduce misuse. Simpler & more robust.
* - ICU-compatible: No exceptions.
* - Need to be able to orphan/release the pointer and its ownership.
* - Need variants for normal C++ object pointers, C++ arrays, and ICU C service objects.
*
* For details see https://icu.unicode.org/design/cpp/scoped_ptr
*/

41#include "unicode/utypes.h"

43#if U_SHOW_CPLUSPLUS_API1

45#include <memory>

47U_NAMESPACE_BEGINnamespace icu_78 {

49/**
* "Smart pointer" base class; do not use directly: use LocalPointer etc.
*
* Base class for smart pointer classes that do not throw exceptions.
*
* Do not use this base class directly, since it does not delete its pointer.
* A subclass must implement methods that delete the pointer:
* Destructor and adoptInstead().
*
* There is no operator T *() provided because the programmer must decide
* whether to use getAlias() (without transfer of ownership) or orphan()
* (with transfer of ownership and NULLing of the pointer).
*
* @see LocalPointer
* @see LocalArray
* @see U_DEFINE_LOCAL_OPEN_POINTER
* @stable ICU 4.4
*/
67template<typename T>
68class LocalPointerBase {
69public:
  // No heap allocation. Use only on the stack.
  static void* U_EXPORT2 operator new(size_t) = delete;
  static void* U_EXPORT2 operator new[](size_t) = delete;
  static void* U_EXPORT2 operator new(size_t, void*) = delete;

  /**
   * Constructor takes ownership.
   * @param p simple pointer to an object that is adopted
   * @stable ICU 4.4
   */
  explicit LocalPointerBase(T *p=nullptr) : ptr(p) {}
7
←
Null pointer value stored to 'languageTypes.ptr'→
  /**
   * Destructor deletes the object it owns.
   * Subclass must override: Base class does nothing.
   * @stable ICU 4.4
   */
  ~LocalPointerBase() { /* delete ptr; */ }
  /**
   * nullptr check.
   * @return true if ==nullptr
   * @stable ICU 4.4
   */
  UBool isNull() const { return ptr==nullptr; }
  /**
   * nullptr check.
   * @return true if !=nullptr
   * @stable ICU 4.4
   */
  UBool isValid() const { return ptr!=nullptr; }
  /**
   * Comparison with a simple pointer, so that existing code
   * with ==nullptr need not be changed.
   * @param other simple pointer for comparison
   * @return true if this pointer value equals other
   * @stable ICU 4.4
   */
  bool operator==(const T *other) const { return ptr==other; }
  /**
   * Comparison with a simple pointer, so that existing code
   * with !=nullptr need not be changed.
   * @param other simple pointer for comparison
   * @return true if this pointer value differs from other
   * @stable ICU 4.4
   */
  bool operator!=(const T *other) const { return ptr!=other; }
  /**
   * Access without ownership change.
   * @return the pointer value
   * @stable ICU 4.4
   */
  T *getAlias() const { return ptr; }
  /**
   * Access without ownership change.
   * @return the pointer value as a reference
   * @stable ICU 4.4
   */
  T &operator*() const { return *ptr; }
  /**
   * Access without ownership change.
   * @return the pointer value
   * @stable ICU 4.4
   */
  T *operator->() const { return ptr; }
  /**
   * Gives up ownership; the internal pointer becomes nullptr.
   * @return the pointer value;
   *         caller becomes responsible for deleting the object
   * @stable ICU 4.4
   */
  T *orphan() {
      T *p=ptr;
      ptr=nullptr;
      return p;
  }
  /**
   * Deletes the object it owns,
   * and adopts (takes ownership of) the one passed in.
   * Subclass must override: Base class does not delete the object.
   * @param p simple pointer to an object that is adopted
   * @stable ICU 4.4
   */
  void adoptInstead(T *p) {
      // delete ptr;
      ptr=p;
  }
155protected:
  /**
   * Actual pointer.
   * @internal
   */
  T *ptr;
161private:
  // No comparison operators with other LocalPointerBases.
  bool operator==(const LocalPointerBase<T> &other) = delete;
  bool operator!=(const LocalPointerBase<T> &other) = delete;
  // No ownership sharing: No copy constructor, no assignment operator.
  LocalPointerBase(const LocalPointerBase<T> &other) = delete;
  void operator=(const LocalPointerBase<T> &other) = delete;
168};

170/**
* "Smart pointer" class, deletes objects via the standard C++ delete operator.
* For most methods see the LocalPointerBase base class.
*
* Usage example:
* \code
* LocalPointer<UnicodeString> s(new UnicodeString((UChar32)0x50005));
* int32_t length=s->length();  // 2
* char16_t lead=s->charAt(0);  // 0xd900
* if(some condition) { return; }  // no need to explicitly delete the pointer
* s.adoptInstead(new UnicodeString((char16_t)0xfffc));
* length=s->length();  // 1
* // no need to explicitly delete the pointer
* \endcode
*
* @see LocalPointerBase
* @stable ICU 4.4
*/
188template<typename T>
189class LocalPointer : public LocalPointerBase<T> {
190public:
  using LocalPointerBase<T>::operator*;
  using LocalPointerBase<T>::operator->;
  /**
   * Constructor takes ownership.
   * @param p simple pointer to an object that is adopted
   * @stable ICU 4.4
   */
  explicit LocalPointer(T *p=nullptr) : LocalPointerBase<T>(p) {}
  /**
   * Constructor takes ownership and reports an error if nullptr.
   *
   * This constructor is intended to be used with other-class constructors
   * that may report a failure UErrorCode,
   * so that callers need to check only for U_FAILURE(errorCode)
   * and not also separately for isNull().
   *
   * @param p simple pointer to an object that is adopted
   * @param errorCode in/out UErrorCode, set to U_MEMORY_ALLOCATION_ERROR
   *     if p==nullptr and no other failure code had been set
   * @stable ICU 55
   */
  LocalPointer(T *p, UErrorCode &errorCode) : LocalPointerBase<T>(p) {
      if(p==nullptr && U_SUCCESS(errorCode)) {
          errorCode=U_MEMORY_ALLOCATION_ERROR;
      }
  }
  /**
   * Move constructor, leaves src with isNull().
   * @param src source smart pointer
   * @stable ICU 56
   */
  LocalPointer(LocalPointer<T> &&src) noexcept : LocalPointerBase<T>(src.ptr) {
      src.ptr=nullptr;
  }

  /**
   * Constructs a LocalPointer from a C++11 std::unique_ptr.
   * The LocalPointer steals the object owned by the std::unique_ptr.
   *
   * This constructor works via move semantics. If your std::unique_ptr is
   * in a local variable, you must use std::move.
   *
   * @param p The std::unique_ptr from which the pointer will be stolen.
   * @stable ICU 64
   */
  explicit LocalPointer(std::unique_ptr<T> &&p)
      : LocalPointerBase<T>(p.release()) {}

  /**
   * Destructor deletes the object it owns.
   * @stable ICU 4.4
   */
  ~LocalPointer() {
      delete LocalPointerBase<T>::ptr;
  }
  /**
   * Move assignment operator, leaves src with isNull().
   * The behavior is undefined if *this and src are the same object.
   * @param src source smart pointer
   * @return *this
   * @stable ICU 56
   */
  LocalPointer<T> &operator=(LocalPointer<T> &&src) noexcept {
      delete LocalPointerBase<T>::ptr;
      LocalPointerBase<T>::ptr=src.ptr;
      src.ptr=nullptr;
      return *this;
  }

  /**
   * Move-assign from an std::unique_ptr to this LocalPointer.
   * Steals the pointer from the std::unique_ptr.
   *
   * @param p The std::unique_ptr from which the pointer will be stolen.
   * @return *this
   * @stable ICU 64
   */
  LocalPointer<T> &operator=(std::unique_ptr<T> &&p) noexcept {
      adoptInstead(p.release());
      return *this;
  }

  /**
   * Swap pointers.
   * @param other other smart pointer
   * @stable ICU 56
   */
  void swap(LocalPointer<T> &other) noexcept {
      T *temp=LocalPointerBase<T>::ptr;
      LocalPointerBase<T>::ptr=other.ptr;
      other.ptr=temp;
  }
  /**
   * Non-member LocalPointer swap function.
   * @param p1 will get p2's pointer
   * @param p2 will get p1's pointer
   * @stable ICU 56
   */
  friend inline void swap(LocalPointer<T> &p1, LocalPointer<T> &p2) noexcept {
      p1.swap(p2);
  }
  /**
   * Deletes the object it owns,
   * and adopts (takes ownership of) the one passed in.
   * @param p simple pointer to an object that is adopted
   * @stable ICU 4.4
   */
  void adoptInstead(T *p) {
      delete LocalPointerBase<T>::ptr;
      LocalPointerBase<T>::ptr=p;
  }
  /**
   * Deletes the object it owns,
   * and adopts (takes ownership of) the one passed in.
   *
   * If U_FAILURE(errorCode), then the current object is retained and the new one deleted.
   *
   * If U_SUCCESS(errorCode) but the input pointer is nullptr,
   * then U_MEMORY_ALLOCATION_ERROR is set,
   * the current object is deleted, and nullptr is set.
   *
   * @param p simple pointer to an object that is adopted
   * @param errorCode in/out UErrorCode, set to U_MEMORY_ALLOCATION_ERROR
   *     if p==nullptr and no other failure code had been set
   * @stable ICU 55
   */
  void adoptInsteadAndCheckErrorCode(T *p, UErrorCode &errorCode) {
      if(U_SUCCESS(errorCode)) {
          delete LocalPointerBase<T>::ptr;
          LocalPointerBase<T>::ptr=p;
          if(p==nullptr) {
              errorCode=U_MEMORY_ALLOCATION_ERROR;
          }
      } else {
          delete p;
      }
  }

  /**
   * Conversion operator to a C++11 std::unique_ptr.
   * Disowns the object and gives it to the returned std::unique_ptr.
   *
   * This operator works via move semantics. If your LocalPointer is
   * in a local variable, you must use std::move.
   *
   * @return An std::unique_ptr owning the pointer previously owned by this
   *         icu::LocalPointer.
   * @stable ICU 64
   */
  operator std::unique_ptr<T> () && {
      return std::unique_ptr<T>(LocalPointerBase<T>::orphan());
  }
343};

345/**
* "Smart pointer" class, deletes objects via the C++ array delete[] operator.
* For most methods see the LocalPointerBase base class.
* Adds operator[] for array item access.
*
* Usage example:
* \code
* LocalArray<UnicodeString> a(new UnicodeString[2]);
* a[0].append((char16_t)0x61);
* if(some condition) { return; }  // no need to explicitly delete the array
* a.adoptInstead(new UnicodeString[4]);
* a[3].append((char16_t)0x62).append((char16_t)0x63).reverse();
* // no need to explicitly delete the array
* \endcode
*
* @see LocalPointerBase
* @stable ICU 4.4
*/
363template<typename T>
364class LocalArray : public LocalPointerBase<T> {
365public:
  using LocalPointerBase<T>::operator*;
  using LocalPointerBase<T>::operator->;
  /**
   * Constructor takes ownership.
   * @param p simple pointer to an array of T objects that is adopted
   * @stable ICU 4.4
   */
  explicit LocalArray(T *p=nullptr) : LocalPointerBase<T>(p) {}
  /**
   * Constructor takes ownership and reports an error if nullptr.
   *
   * This constructor is intended to be used with other-class constructors
   * that may report a failure UErrorCode,
   * so that callers need to check only for U_FAILURE(errorCode)
   * and not also separately for isNull().
   *
   * @param p simple pointer to an array of T objects that is adopted
   * @param errorCode in/out UErrorCode, set to U_MEMORY_ALLOCATION_ERROR
   *     if p==nullptr and no other failure code had been set
   * @stable ICU 56
   */
  LocalArray(T *p, UErrorCode &errorCode) : LocalPointerBase<T>(p) {
      if(p==nullptr && U_SUCCESS(errorCode)) {
          errorCode=U_MEMORY_ALLOCATION_ERROR;
      }
  }
  /**
   * Move constructor, leaves src with isNull().
   * @param src source smart pointer
   * @stable ICU 56
   */
  LocalArray(LocalArray<T> &&src) noexcept : LocalPointerBase<T>(src.ptr) {
      src.ptr=nullptr;
  }

  /**
   * Constructs a LocalArray from a C++11 std::unique_ptr of an array type.
   * The LocalPointer steals the array owned by the std::unique_ptr.
   *
   * This constructor works via move semantics. If your std::unique_ptr is
   * in a local variable, you must use std::move.
   *
   * @param p The std::unique_ptr from which the array will be stolen.
   * @stable ICU 64
   */
  explicit LocalArray(std::unique_ptr<T[]> &&p)
      : LocalPointerBase<T>(p.release()) {}

  /**
   * Destructor deletes the array it owns.
   * @stable ICU 4.4
   */
  ~LocalArray() {
      delete[] LocalPointerBase<T>::ptr;
  }
  /**
   * Move assignment operator, leaves src with isNull().
   * The behavior is undefined if *this and src are the same object.
   * @param src source smart pointer
   * @return *this
   * @stable ICU 56
   */
  LocalArray<T> &operator=(LocalArray<T> &&src) noexcept {
      delete[] LocalPointerBase<T>::ptr;
      LocalPointerBase<T>::ptr=src.ptr;
      src.ptr=nullptr;
      return *this;
  }

  /**
   * Move-assign from an std::unique_ptr to this LocalPointer.
   * Steals the array from the std::unique_ptr.
   *
   * @param p The std::unique_ptr from which the array will be stolen.
   * @return *this
   * @stable ICU 64
   */
  LocalArray<T> &operator=(std::unique_ptr<T[]> &&p) noexcept {
      adoptInstead(p.release());
      return *this;
  }

  /**
   * Swap pointers.
   * @param other other smart pointer
   * @stable ICU 56
   */
  void swap(LocalArray<T> &other) noexcept {
      T *temp=LocalPointerBase<T>::ptr;
      LocalPointerBase<T>::ptr=other.ptr;
      other.ptr=temp;
  }
  /**
   * Non-member LocalArray swap function.
   * @param p1 will get p2's pointer
   * @param p2 will get p1's pointer
   * @stable ICU 56
   */
  friend inline void swap(LocalArray<T> &p1, LocalArray<T> &p2) noexcept {
      p1.swap(p2);
  }
  /**
   * Deletes the array it owns,
   * and adopts (takes ownership of) the one passed in.
   * @param p simple pointer to an array of T objects that is adopted
   * @stable ICU 4.4
   */
  void adoptInstead(T *p) {
      delete[] LocalPointerBase<T>::ptr;
      LocalPointerBase<T>::ptr=p;
  }
  /**
   * Deletes the array it owns,
   * and adopts (takes ownership of) the one passed in.
   *
   * If U_FAILURE(errorCode), then the current array is retained and the new one deleted.
   *
   * If U_SUCCESS(errorCode) but the input pointer is nullptr,
   * then U_MEMORY_ALLOCATION_ERROR is set,
   * the current array is deleted, and nullptr is set.
   *
   * @param p simple pointer to an array of T objects that is adopted
   * @param errorCode in/out UErrorCode, set to U_MEMORY_ALLOCATION_ERROR
   *     if p==nullptr and no other failure code had been set
   * @stable ICU 56
   */
  void adoptInsteadAndCheckErrorCode(T *p, UErrorCode &errorCode) {
      if(U_SUCCESS(errorCode)) {
          delete[] LocalPointerBase<T>::ptr;
          LocalPointerBase<T>::ptr=p;
          if(p==nullptr) {
              errorCode=U_MEMORY_ALLOCATION_ERROR;
          }
      } else {
          delete[] p;
      }
  }
  /**
   * Array item access (writable).
   * No index bounds check.
   * @param i array index
   * @return reference to the array item
   * @stable ICU 4.4
   */
  T &operator[](ptrdiff_t i) const { return LocalPointerBase<T>::ptr[i]; }

  /**
   * Conversion operator to a C++11 std::unique_ptr.
   * Disowns the object and gives it to the returned std::unique_ptr.
   *
   * This operator works via move semantics. If your LocalPointer is
   * in a local variable, you must use std::move.
   *
   * @return An std::unique_ptr owning the pointer previously owned by this
   *         icu::LocalPointer.
   * @stable ICU 64
   */
  operator std::unique_ptr<T[]> () && {
      return std::unique_ptr<T[]>(LocalPointerBase<T>::orphan());
  }
526};

528/**
* \def U_DEFINE_LOCAL_OPEN_POINTER
* "Smart pointer" definition macro, deletes objects via the closeFunction.
* Defines a subclass of LocalPointerBase which works just
* like LocalPointer<Type> except that this subclass will use the closeFunction
* rather than the C++ delete operator.
*
* Usage example:
* \code
* LocalUCaseMapPointer csm(ucasemap_open(localeID, options, &errorCode));
* utf8OutLength=ucasemap_utf8ToLower(csm.getAlias(),
*     utf8Out, (int32_t)sizeof(utf8Out),
*     utf8In, utf8InLength, &errorCode);
* if(U_FAILURE(errorCode)) { return; }  // no need to explicitly delete the UCaseMap
* \endcode
*
* @see LocalPointerBase
* @see LocalPointer
* @stable ICU 4.4
*/
548#define U_DEFINE_LOCAL_OPEN_POINTER(LocalPointerClassName, Type, closeFunction)using LocalPointerClassName = internal::LocalOpenPointer<Type
, closeFunction> \
  using LocalPointerClassName = internal::LocalOpenPointer<Type, closeFunction>

551#ifndef U_IN_DOXYGEN
552namespace internal {
553/**
* Implementation, do not use directly: use U_DEFINE_LOCAL_OPEN_POINTER.
*
* @see U_DEFINE_LOCAL_OPEN_POINTER
* @internal
*/
559template <typename Type, auto closeFunction>
560class LocalOpenPointer : public LocalPointerBase<Type> {
  using LocalPointerBase<Type>::ptr;
562public:
  using LocalPointerBase<Type>::operator*;
  using LocalPointerBase<Type>::operator->;
  explicit LocalOpenPointer(Type *p=nullptr) : LocalPointerBase<Type>(p) {}
  LocalOpenPointer(LocalOpenPointer &&src) noexcept
          : LocalPointerBase<Type>(src.ptr) {
      src.ptr=nullptr;
  }
  /* TODO: Be agnostic of the deleter function signature from the user-provided std::unique_ptr? */
  explicit LocalOpenPointer(std::unique_ptr<Type, decltype(closeFunction)> &&p)
          : LocalPointerBase<Type>(p.release()) {}
  ~LocalOpenPointer() { if (ptr != nullptr) { closeFunction(ptr); } }
  LocalOpenPointer &operator=(LocalOpenPointer &&src) noexcept {
      if (ptr != nullptr) { closeFunction(ptr); }
      LocalPointerBase<Type>::ptr=src.ptr;
      src.ptr=nullptr;
      return *this;
  }
  /* TODO: Be agnostic of the deleter function signature from the user-provided std::unique_ptr? */
  LocalOpenPointer &operator=(std::unique_ptr<Type, decltype(closeFunction)> &&p) {
      adoptInstead(p.release());
      return *this;
  }
  void swap(LocalOpenPointer &other) noexcept {
      Type *temp=LocalPointerBase<Type>::ptr;
      LocalPointerBase<Type>::ptr=other.ptr;
      other.ptr=temp;
  }
  friend inline void swap(LocalOpenPointer &p1, LocalOpenPointer &p2) noexcept {
      p1.swap(p2);
  }
  void adoptInstead(Type *p) {
      if (ptr != nullptr) { closeFunction(ptr); }
      ptr=p;
  }
  operator std::unique_ptr<Type, decltype(closeFunction)> () && {
      return std::unique_ptr<Type, decltype(closeFunction)>(LocalPointerBase<Type>::orphan(), closeFunction);
  }
600};
601}  // namespace internal
602#endif

604U_NAMESPACE_END}

606#endif  /* U_SHOW_CPLUSPLUS_API */
607#endif  /* __LOCALPOINTER_H__ */